elabs_matchers 0.0.3 → 0.0.4

data/lib/elabs_matchers/matchers/contain_hash.rb

@@ -0,0 +1,58 @@
+module ElabsMatchers
+  module Matchers
+    module ContainHash
+      rspec
+
+      class ContainHashMatcher < Struct.new(:expected, :actual)
+        def matches?(actual)
+          @actual = actual
+          contains?(expected, actual)
+        end
+
+        def failure_message_for_should
+          "Expected #{expected.inspect} to exist in #{actual.inspect} but it did not."
+        end
+
+        def failure_message_for_should_not
+          "Expected #{expected.inspect} to not exist in #{actual.inspect} but it did."
+        end
+
+        private
+
+        def contains?(expected, actual)
+          return false unless actual.is_a?(expected.class)
+
+          if expected.is_a?(Array)
+            expected.all? do |expected_value|
+              actual.any? do |actual_value|
+                contains?(expected_value, actual_value)
+              end
+            end
+          elsif expected.is_a?(Hash)
+            expected.all? do |key, value|
+              contains?(value, actual[key])
+            end
+          else
+            actual == expected
+          end
+        end
+
+      end
+
+      ##
+      #
+      # Asserts if the hash contains the supplied hash.
+      # Works with nested hashes and array of hashes.
+      #
+      # @param [Hash] hash      Key => value pairs seperated by comma
+      #
+      # Example:
+      # { "foo" => ["quox", { "bar" => "baz"}]}.should contain_hash({ "foo" => [{ "bar" => "baz" }]})
+      # { "foo" => "bar", "baz" => "quox" }.should_not contain_hash({ "baz" => "bar" })
+
+      def contain_hash(hash)
+        ContainHashMatcher.new(hash)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_attribute.rb

@@ -0,0 +1,62 @@
+module ElabsMatchers
+  module Matchers
+    module HaveAttribute
+      rspec :type => :request
+
+      class HaveAttributeMatcher < Struct.new(:label, :value)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          page.has_selector?(selector_type, selector)
+        end
+
+        def does_not_match?(page)
+          @page = page
+          page.has_no_selector?(selector_type, selector)
+        end
+
+        def failure_message_for_should
+          attributes = page.all(:css, "li.wrapper").map(&:text).to_sentence
+          "expected there to be an attribute #{label}: #{value}, but the only attributes were: #{attributes}."
+        end
+
+        def failure_message_for_should_not
+          "expected there to be no attribute #{label}: #{value}, but there was."
+        end
+
+        private
+
+        def selector_type
+          ElabsMatchers.attribute_selector_type
+        end
+
+        def selector
+          if ElabsMatchers.attribute_selector
+            ElabsMatchers.attribute_selector[label, value]
+          else
+            XPath.generate do |x|
+              x.descendant(:p)[x.attr(:class).contains("wrapper")][x.child(:strong).contains(label)][x.contains(value)]
+            end
+          end
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied show_for* attribute exists or not
+      #
+      # @param [String] label            The name of the attribute.
+      # @param [String] value            The value of the attribute.
+      #
+      # Example:
+      # page.should have_attribute("Status", "Pending")
+      #
+      # * https://github.com/plataformatec/show_for
+
+      def have_attribute(label, value)
+        HaveAttributeMatcher.new(label, value)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_fields.rb

@@ -0,0 +1,45 @@
+module ElabsMatchers
+  module Matchers
+    module HaveFields
+      rspec :type => :request
+
+      class HaveFieldsMatcher < Struct.new(:fields)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          fields.all? { |label, value| page.has_field?(label, :with => value) }
+        end
+
+        def does_not_match?(page)
+          @page = page
+          fields.all? { |label, value| page.has_no_field?(label, :with => value) }
+        end
+
+        def failure_message_for_should
+          field_values = page.all("input, textarea").map { |input| input[:value] }
+
+          "expected page to have the fields #{fields.inspect}, but it didn't.
+           The fields on the page had the following values: #{field_values.to_sentence}."
+        end
+
+        def failure_message_for_should_not
+          "expected page not to have the fields #{fields.inspect}, but it did."
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied fields exists or not
+      #
+      # @param [Hash] fields         A hash containing pairs of field name => value
+      #
+      # Example:
+      # page.should have_fields("Author" => "Adam", "Year" => "2011")
+
+      def have_fields(fields)
+        HaveFieldsMatcher.new(fields)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_flash.rb

@@ -0,0 +1,65 @@
+module ElabsMatchers
+  module Matchers
+    module HaveFlash
+      rspec :type => :request
+
+      class HaveFlashMatcher < Struct.new(:type, :message)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          page.has_selector?(selector_type, selector, :text => message)
+        end
+
+        def does_not_match?(page)
+          @page = page
+          page.has_no_selector?(selector_type, selector, :text => message)
+        end
+
+        def failure_message_for_should
+          "Expected flash #{type} to be '#{message}' but was '#{page.find(selector_type, selector).text}'."
+        end
+
+        def failure_message_for_should_not
+          "Expected flash #{type} to not be '#{message}' but it was."
+        end
+
+        private
+
+        def selector_type
+          ElabsMatchers.send(:"flash_#{type}_selector_type")
+        end
+
+        def selector
+          ElabsMatchers.send(:"flash_#{type}_selector")
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied flash notice exists or not
+      #
+      # @param [String] message              The content of the flash notice
+      #
+      # Example:
+      # page.should have_flash_notice("Success")
+
+      def have_flash_notice(message)
+        HaveFlashMatcher.new(:notice, message)
+      end
+
+      ##
+      #
+      # Asserts if the supplied flash alert exists or not
+      #
+      # @param [String] message              The content of the flash alert
+      #
+      # Example:
+      # page.should have_flash_alert("Error")
+
+      def have_flash_alert(message)
+        HaveFlashMatcher.new(:alert, message)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_form_errors_on.rb

@@ -0,0 +1,79 @@
+module ElabsMatchers
+  module Matchers
+    module HaveFormErrorsOn
+      rspec :type => :request
+
+      class HaveFormErrorsOnMatcher < Struct.new(:field, :message)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+
+          if page.has_field?(field)
+            page.find_field(field).has_selector?(selector_type, selector, :text => message)
+          end
+        end
+
+        def does_not_match?(page)
+          @page = page
+          page.has_no_field?(field) || page.find_field(field).has_no_selector?(selector_type, selector, :text => message)
+        end
+
+        def failure_message_for_should
+          if page.has_field?(field)
+            error = page.find_field(field).all(selector_type, selector).first
+            if not error
+              "Expected field '#{field}' to have an error, but it didn't."
+            elsif error.text != message
+              "Expected error message on #{field} to be '#{message}' but was '#{error.text}'."
+            end
+          else
+            "No such field #{field}."
+          end
+        end
+
+        def failure_message_for_should_not
+          "Expected error message on '#{field}' not to be '#{message}' but it was."
+        end
+
+        private
+
+        def selector_type
+          :xpath
+        end
+
+        def selector
+          if ElabsMatchers.form_errors_on_selector
+            ElabsMatchers.form_errors_on_selector
+          else
+            outside_input_container_xpath = %Q{ancestor::*[contains(@class, 'field_with_errors') and contains(@class, 'error')]}
+            error_as_sibling_xpath = %Q{..//span[contains(@class,'error')]}
+            input_nested_in_label_xpath = %Q{..//..//label/following-sibling::*[1]/self::span[@class='error']}
+            twitter_bootstrap_xpath = %Q{ancestor::*[contains(concat(' ', @class, ' '), ' control-group ') and contains(concat(' ', @class, ' '), ' error ')]}
+
+            [
+              outside_input_container_xpath,
+              error_as_sibling_xpath,
+              input_nested_in_label_xpath,
+              twitter_bootstrap_xpath
+            ].join(" | ")
+          end
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied flash alert exists or not
+      #
+      # @param [String] field               The label content associated with the field. Any selector which works with has_field? works here too.
+      # @param [String] message             The error message expected.
+      #
+      # Example:
+      # page.should have_form_errors_on("Name", "Can't be blank")
+
+      def have_form_errors_on(field, message)
+        HaveFormErrorsOnMatcher.new(field, message)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_header.rb

@@ -0,0 +1,53 @@
+module ElabsMatchers
+  module Matchers
+    module HaveHeader
+      rspec :type => :request
+
+      class HaveHeaderMatcher < Struct.new(:text)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          page.has_selector?(selector_type, selector, :text => text)
+        end
+
+        def does_not_match?(page)
+          @page = page
+          page.has_no_selector?(selector_type, selector, :text => text)
+        end
+
+        def failure_message_for_should
+          headers = page.all(selector_type, selector).map { |h| "'#{h.text}'" }.to_sentence
+          "Expected header to be '#{text}' but it had the headers #{headers}."
+        end
+
+        def failure_message_for_should_not
+          "Expected header not to be '#{text}' but it was."
+        end
+
+        private
+
+        def selector
+          ElabsMatchers.header_selector
+        end
+
+        def selector_type
+          ElabsMatchers.header_selector_type
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied header exists or not
+      #
+      # @param [String] text              The content of the header
+      #
+      # Example:
+      # page.should have_header("Elabs")
+
+      def have_header(text)
+        HaveHeaderMatcher.new(text)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_image.rb

@@ -0,0 +1,69 @@
+module ElabsMatchers
+  module Matchers
+    module HaveImage
+      rspec :type => :request
+
+      class HaveImageMatcher < Struct.new(:value)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          page.has_selector?(selector_type, selector)
+        end
+
+        def does_not_match?(page)
+          @page = page
+          page.has_no_selector?(selector_type, selector)
+        end
+
+        def failure_message_for_should
+          images = page.all("img").map do |image|
+            hash = {}
+            hash[:alt]   = image[:alt]   if image[:alt].present?
+            hash[:src]   = image[:src]   if image[:src].present?
+            hash[:id]    = image[:id]    if image[:id].present?
+            hash[:class] = image[:class] if image[:class].present?
+            hash
+          end.to_sentence
+
+          if ElabsMatchers.image_selector.nil?
+            "expected image alt to be '#{value}' but only had the images: #{images}."
+          else
+            "expected to find image '#{value}' but only had the images: #{images}."
+          end
+        end
+
+        def failure_message_for_should_not
+          "expected image not to be '#{value}' but it was."
+        end
+
+        private
+
+        def selector_type
+          ElabsMatchers.image_selector_type
+        end
+
+        def selector
+          if ElabsMatchers.image_selector
+            ElabsMatchers.image_selector[value]
+          else
+            "img[alt=\"#{value}\"]"
+          end
+        end
+      end
+
+      ##
+      #
+      # Asserts if the supplied image exists or not
+      #
+      # @param [String] value              The alt attribute content of the image
+      #
+      # Example:
+      # page.should have_image("Logo")
+
+      def have_image(value)
+        HaveImageMatcher.new(value)
+      end
+    end
+  end
+end

data/lib/elabs_matchers/matchers/have_table_row.rb

@@ -0,0 +1,113 @@
+module ElabsMatchers
+  module Matchers
+    module HaveTableRow
+      rspec :type => :request
+
+      class HaveTableRowMatcher < Struct.new(:table_name, :row)
+        attr_reader :page
+
+        def matches?(page)
+          @page = page
+          table and table.has_selector?(selector_type, selector)
+        end
+
+        def does_not_match?(page)
+          @page = page
+          !table or table.has_no_selector?(selector_type, selector)
+        end
+
+        def failure_message_for_should
+          "Expected #{row.inspect} to be included in the table #{table_name}, but it wasn't:\n\n#{ascii_table}"
+        end
+
+        def failure_message_for_should_not
+          "Expected there to be no table #{table_name} with row #{row.inspect}, but there was.\n\n#{ascii_table}"
+        end
+
+        private
+
+        def selector_type
+          :xpath
+        end
+
+        def selector
+          if ElabsMatchers.table_row_selector
+            ElabsMatchers.table_row_selector[row, table]
+          else
+            exps = row.map do |header, value|
+              col_index = table.all("th").index { |th| th.text.include?(header.to_s) }
+              col_index = if col_index then col_index + 1 else 0 end
+
+              XPath.generate do |x|
+                cell = x.child(:td, :th)[col_index.to_s.to_sym]
+
+                if value.blank?
+                  cell["not(node())".to_sym].or(cell.descendant(:input)["string-length(normalize-space(@value))=0".to_sym])
+                else
+                  cell[x.contains(value).or(x.descendant(:input)[x.attr(:value).contains(value)])]
+                end
+              end
+            end
+
+            XPath.descendant["tr"][exps.reduce(:&)]
+          end
+        end
+
+        def table
+          table_xpath = XPath::HTML.table(table_name)
+
+          if page.has_xpath?(table_xpath)
+            page.find(:xpath, table_xpath)
+          end
+        end
+
+        def ascii_table
+          if table
+            column_lengths = []
+            table.all("tr").map do |tr|
+              tr.all("td,th").each_with_index do |td, i|
+                size = td_content(td).strip.size
+                if (column_lengths[i] || 0) < size
+                  column_lengths[i] = size
+                end
+              end
+            end
+
+            table.all("tr").map do |tr|
+              middle = []
+              space = if tr.all("td,th").first.tag_name == "th" then "_" else " " end
+              wall = "|"
+
+              tr.all("td,th").each_with_index do |td, i|
+                middle << td_content(td).strip.ljust(column_lengths[i], space)
+              end
+
+              [wall, space, middle.join(space + wall + space), space, wall].join
+            end.join("\n")
+          end
+        end
+
+        def td_content(td)
+          text = td.text.presence
+          text ||= td.find("input, textarea")[:value] if td.has_css?("input")
+          text || ""
+        end
+      end
+
+
+      ##
+      #
+      # Asserts if the supplied table row exists in the table
+      #
+      # @param [String] table_name            The tables's caption text.
+      # @param [Hash] row                     A hash representing the column name and value in key-value form.
+      #
+      # Example:
+      # table.should have_table_row("Posts", "Title" => "First", :year => "2012")
+
+      def have_table_row(table_name, row)
+        HaveTableRowMatcher.new(table_name, row)
+      end
+    end
+  end
+end