elabs_matchers 0.0.3 → 0.0.4

data/lib/elabs_matchers/matchers/capybara/common.rb

@@ -1,245 +0,0 @@
-module ElabsMatchers
-  module Matchers
-    module Capybara
-      module Common
-        ##
-        #
-        # Asserts if the select input tag contains the given options.
-        #
-        # @param [Array] options      One or serveral strings seperated by comma
-        #
-        # Example:
-        # find(:xpath, XPath::HTML.select("My input label")).should have_options(options)
-
-        RSpec::Matchers.define :have_options do |*options|
-          match do |select|
-            options.all? { |option| select.all("option").map(&:text).include?(option) }
-          end
-
-          failure_message_for_should do |select|
-            actual_options = select.all("option").map(&:text).inspect
-            "expected options to include '#{options.flatten.inspect}' but it had the options #{actual_options}."
-          end
-          failure_message_for_should_not { |select| "expected options not to include '#{options.flatten.inspect}' but it did." }
-        end
-
-        ##
-        #
-        # Asserts if the supplied table row exists in the table
-        #
-        # @param [String] table name            The tables's caption text.
-        # @param [Hash] column value            A hash representing the column name and value in key-value form.
-        #
-        # Example:
-        # table.should have_table_row('Posts', "Title" => "First", :year => "2012")
-
-        RSpec::Matchers.define :have_table_row do |table_name, row|
-          match do |page|
-            table = page.find(:xpath, XPath::HTML.table(table_name))
-
-            if row.is_a? Hash
-              exps = row.map do |header, value|
-                col_index = table.all("thead th").index { |th| th.text.include?(header) }
-                col_index = if col_index then col_index + 1 else 0 end
-                XPath.child(:td, :th)[col_index.to_s.to_sym][XPath.contains(value)]
-              end
-              exps = exps.inject { |agg, exp| agg & exp }
-              table.has_xpath?(XPath.descendant['tr'][exps])
-            else
-              exps = []
-              row.each_with_index do |value, index|
-                exps << XPath.child(:td)[(index + 1).to_s.to_sym][XPath.contains(value)]
-              end
-              exps = exps.inject { |agg, exp| agg & exp }
-
-              table.has_xpath?(XPath.descendant['tr'][exps])
-            end
-          end
-
-          match_for_should_not do |page|
-            table = page.find(:xpath, XPath::HTML.table(table_name))
-
-            if row.is_a? Hash
-              exps = row.map do |header, value|
-                col_index = table.all("thead th").index { |th| th.text.include?(header) }
-                col_index = if col_index then col_index + 1 else 0 end
-                XPath.child(:td, :th)[col_index.to_s.to_sym][XPath.contains(value)]
-              end
-              exps = exps.inject { |agg, exp| agg & exp }
-              table.has_no_xpath?(XPath.descendant['tr'][exps])
-            else
-              exps = []
-              row.each_with_index do |value, index|
-                exps << XPath.child(:td)[(index + 1).to_s.to_sym][XPath.contains(value)]
-              end
-              exps = exps.inject { |agg, exp| agg & exp }
-
-              table.has_no_xpath?(XPath.descendant['tr'][exps])
-            end
-          end
-
-          failure_message_for_should do |page|
-            table = page.find(:xpath, XPath::HTML.table(table_name))
-            ascii_table = table.all('tr').map do |tr|
-              '| ' + tr.all('td,th').map { |td| td.text.strip.ljust(21) }.join(' | ') + ' |'
-            end.join("\n")
-            "expected #{row.inspect} to be included in the table #{table_name}, but it wasn't:\n\n#{ascii_table}"
-          end
-          failure_message_for_should_not { |page| "expected there to be no table #{table_name} with row #{row.inspect}, but there was." }
-        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
-
-        RSpec::Matchers.define :have_attribute do |label, value|
-          xpath = XPath.generate { |x| x.descendant(:p)[x.attr(:class).contains('wrapper')][x.child(:strong).contains(label)][x.contains(value)] }
-
-          match do |page|
-            page.has_xpath?(xpath)
-          end
-
-          match_for_should_not do |page|
-            page.has_no_xpath?(xpath)
-          end
-
-          failure_message_for_should do |page|
-            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
-          failure_message_for_should_not { |page| "expected there to be no attribute #{label}: #{value}, but there was." }
-        end
-
-        ##
-        #
-        # Asserts if the supplied image exists or not
-        #
-        # @param [String] alt              The alt attribute content of the image
-        #
-        # Example:
-        # page.should have_image("Logo")
-
-        RSpec::Matchers.define :have_image do |alt|
-          match { |page| page.has_css?("img[alt=\"#{alt}\"]") }
-          match_for_should_not { |page| page.has_no_css?("img[alt=\"#{alt}\"]") }
-
-          failure_message_for_should do |page|
-            alts = page.all('img').map { |img| "'#{img[:alt]}'" }.to_sentence
-            "expected image alt to be '#{alt}' but it had the image alts: #{alts}."
-          end
-          failure_message_for_should_not { |page| "expected image not to be '#{alt}' but it was" }
-        end
-
-        ##
-        #
-        # Asserts if the supplied header exists or not
-        #
-        # @param [String] text              The content of the header
-        #
-        # Example:
-        # page.should have_header("Elabs")
-
-        RSpec::Matchers.define :have_header do |text|
-          match { |page| page.has_css?('h1,h2', :text => text) }
-          match_for_should_not { |page| page.has_no_css?('h1,h2', :text => text) }
-
-          failure_message_for_should do |page|
-            headers = page.all('h1,h2').map { |h| "'#{h.text}'" }.to_sentence
-            "expected header to be '#{text}' but it had the headers #{headers}"
-          end
-          failure_message_for_should_not { |page| "expected header not to be '#{text}' but it was" }
-        end
-
-        ##
-        #
-        # Asserts if the supplied flash notice exists or not
-        #
-        # @param [String] text              The content of the flash notice
-        #
-        # Example:
-        # page.should have_flash_notice("Success")
-
-        RSpec::Matchers.define :have_flash_notice do |text|
-          match { |page| page.has_css?('#flash.notice, #flash .notice', :text => text) }
-          match_for_should_not { |page| page.has_no_css?('#flash.notice, #flash .notice', :text => text) }
-          failure_message_for_should { |page| "expected flash notice to be '#{text}' but was '#{page.find('#flash.notice').text}'" }
-          failure_message_for_should_not { |page| "expected flash notice not to be '#{text}' but it was" }
-        end
-
-        ##
-        #
-        # Asserts if the supplied flash alert exists or not
-        #
-        # @param [String] text              The content of the flash alert
-        #
-        # Example:
-        # page.should have_flash_alert("Error")
-
-        RSpec::Matchers.define :have_flash_alert do |text|
-          match { |page| page.has_css?('#flash.alert, #flash .alert', :text => text) }
-          match_for_should_not { |page| page.has_no_css?('#flash.alert, #flash .alert', :text => text) }
-          failure_message_for_should { |page| "expected flash alert to be '#{text}' but was '#{page.find('#flash.alert').text}'" }
-          failure_message_for_should_not { |page| "expected flash alert not to be '#{text}' but it was" }
-        end
-
-        ##
-        #
-        # Asserts if the supplied flash alert exists or not
-        #
-        # @param [String] label              The label content associated with the field.
-        # @param [String] message             The error message expected.
-        #
-        # Example:
-        # page.should have_form_errors_on("Name", "Can't be blank")
-
-        RSpec::Matchers.define :have_form_errors_on do |field, message|
-          xpath = %Q{..//span[contains(@class,'error')]}
-          match { |page| page.has_field?(field) and page.find_field(field).has_xpath?(xpath, :text => message) }
-          match_for_should_not { |page| page.has_no_field?(field) or page.find_field(field).has_no_xpath?(xpath, :text => message) }
-
-          failure_message_for_should do |page|
-            error = page.find_field(field).all(:xpath, xpath).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}'"
-            else
-              raise "This should not happen"
-            end
-          end
-          failure_message_for_should_not { |page| "expected error message on '#{field}' not to be '#{text}' but it was" }
-        end
-
-        ##
-        #
-        # Asserts if the supplied fields exists or not
-        #
-        # @param [Hash] field name, value         A hash containing pairs of field name => value
-        #
-        # Example:
-        # page.should have_fields("Author" => "Adam", "Year" => "2011")
-
-        RSpec::Matchers.define :have_fields do |fields|
-          match do |page|
-            exps = fields.map { |label, value| XPath::HTML.field(label, :with => value) }
-            page.has_xpath?("(./html | ./self::*)[#{exps.join(' and ')}]")
-          end
-          match_for_should_not do |page|
-            exps = fields.map { |label, value| XPath::HTML.field(label, :with => value) }
-            page.has_no_xpath?("(./html | ./self::*)[#{exps.join(' and ')}]")
-          end
-          failure_message_for_should { |page| "expected page to have the fields #{fields.inspect}, but it didn't." }
-          failure_message_for_should_not { |page| "expected page not to have the fields #{fields.inspect}, but it did." }
-        end
-      end
-    end
-  end
-end

data/lib/elabs_matchers/matchers/rspec/allow.rb

@@ -1,112 +0,0 @@
-module ElabsMatchers
-  module Matchers
-    module Rspec
-      module Allow
-
-        ##
-        #
-        # Asserts if a sample value is valid on a given attribute
-        #
-        # @param [*Array] sample value(s)     Sample value(s) to check the validation against
-        # @param [*Array] method name(s)      The method name(s) that has the validation(s) attached to it
-        #
-        # Example:
-        # post.should allow("Elabs").as(:title)
-        # post.should_not allow("").as(:title)
-        #
-        # post.should allow("Elabs").as(:title, :body)
-        # post.should_not allow("").as(:title, :body)
-        #
-        # post.should allow("Elabs", "Sweden").as(:title)
-        # post.should_not allow("", nil).as(:title)
-        #
-        # post.should allow("Elabs", "Sweden").as(:title, :body)
-        # post.should_not allow("", nil).as(:title, :body)
-
-        if defined?(ActiveModel)
-          RSpec::Matchers.define :allow do |*values|
-            chain :as do |*attributes|
-              @attributes = [*attributes]
-            end
-
-            match_for_should do |actual|
-              @actual, @values = actual, values
-              errors.none?
-            end
-
-            match_for_should_not do |actual|
-              @actual, @values = actual, values
-              errors.all? and correct_number_of_errors?
-            end
-
-            def correct_number_of_errors?
-              @num_errors = errors.length
-
-              if attributes?
-                if values?
-                  matches_number_of_errors?(attributes, values)
-                else
-                  matches_number_of_errors?(attributes)
-                end
-              else
-                if values?
-                  matches_number_of_errors?(values)
-                else
-                  matches_number_of_errors?(1)
-                end
-              end
-            end
-
-            def errors
-              values.map do |value|
-                errors_with(value)
-              end.flatten.compact
-            end
-
-            def errors_with(value)
-              attributes.each do |attribute|
-                actual.send(:"#{attribute}=", value)
-              end
-
-              actual.valid?
-
-              attributes.map do |attribute|
-                actual.errors.has_key?(attribute)
-              end
-            end
-
-            def matches_number_of_errors?(list1, list2 = [])
-              @num_errors == ([*list1] + list2).flatten.length
-            end
-
-            def attributes?; attributes.length > 1 ; end
-            def values?    ; values.length > 1     ; end
-            def attributes ; @attributes           ; end
-            def values     ; [*@values]            ; end
-            def actual     ; @actual               ; end
-
-            failure_message_for_should do |actual|
-              common_failure_message(:valid)
-            end
-
-            failure_message_for_should_not do |actual|
-              common_failure_message(:invalid)
-            end
-
-            def common_failure_message(match_type)
-              "Expected #{expected_values_explain} to be #{match_type} on #{actual.class.model_name.demodulize}'s #{attributes_values_explain} attributes but it wasn't."
-            end
-
-            def expected_values_explain
-              values.map(&:inspect).to_sentence(:two_words_connector => ' or ')
-            end
-
-            def attributes_values_explain
-              attributes.map(&:to_s).map(&:inspect).to_sentence
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/elabs_matchers/matchers/rspec/common.rb

@@ -1,59 +0,0 @@
-module ElabsMatchers
-  module Matchers
-    module Rspec
-      module Common
-        ##
-        #
-        # Asserts if the hash contains the supplied hash.
-        # Works with nested hashes and array of hashes.
-        #
-        # @param [Hash] options      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" })
-
-        RSpec::Matchers.define :contain_hash do |expected|
-          match do |actual|
-            contains?(expected, actual)
-          end
-
-          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 array contains exactly the supplied elements.
-        # The order of the element do not have to match.
-        #
-        # @param argument list options      comma seperated list of arguments
-        #
-        # Example:
-        # ["foo", "bar"].should only_include("bar", "foo")
-        # ["foo", "bar"].should_not only_include("foo")
-
-        RSpec::Matchers.define :only_include do |*collection|
-          match { |actual| actual.length == collection.length and collection.all? { |element| actual.include?(element) }  }
-          failure_message_for_should { |actual| "Expected #{actual.inspect} to only include #{collection.inspect}." }
-          failure_message_for_should_not { |actual| "Expected #{actual.inspect} to not only include #{collection.inspect}, but it did." }
-        end
-      end
-    end
-  end
-end

data/lib/elabs_matchers/matchers/rspec/orm.rb

@@ -1,29 +0,0 @@
-module ElabsMatchers
-  module Matchers
-    module Rspec
-      module Orm
-        ##
-        #
-        # Asserts if an assigned value persistes in the database.
-        #
-        # @param [Symbol] attribute name      The name of the attibute to check if it persisted or not
-        # @param [Object] value               The value to persist to the attribute
-        #
-        # Example:
-        # post.should persist(:title, "Blog post")
-
-        RSpec::Matchers.define :persist do |attribute, value|
-          match do |actual|
-            actual.send(:"#{attribute}=", value)
-            actual.save!
-            actual = actual.class.find(actual.id)
-            @final_value = actual.send(attribute)
-            @final_value == value
-          end
-          failure_message_for_should { |actual| "Expected #{attribute} to be persisted and retain its value of #{value.inspect} but the value was #{@final_value.inspect}" }
-          failure_message_for_should_not { |actual| "Expected #{attribute} not to be persisted and retain its value of #{value.inspect} but it did." }
-        end
-      end
-    end
-  end
-end