rspec-sleeping_king_studios 2.1.1 → 2.2.0.rc.1

data/lib/rspec/sleeping_king_studios/matchers/active_model/have_errors_matcher.rb

@@ -0,0 +1,268 @@
+# lib/rspec/sleeping_king_studios/matchers/active_model/have_errors_matcher.rb
+require 'rspec/sleeping_king_studios/matchers/base_matcher'
+require 'rspec/sleeping_king_studios/matchers/active_model'
+require 'rspec/sleeping_king_studios/matchers/active_model/have_errors/error_expectation'
+require 'sleeping_king_studios/tools/array_tools'
+require 'sleeping_king_studios/tools/string_tools'
+
+module RSpec::SleepingKingStudios::Matchers::ActiveModel
+  # Matcher for testing ActiveModel object validations.
+  #
+  # @since 1.0.0
+  class HaveErrorsMatcher < RSpec::SleepingKingStudios::Matchers::BaseMatcher
+    include RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrors
+
+    def initialize
+      super
+
+      # The error and message expectations are set up through #on and
+      # #with_message.
+      @error_expectations = []
+    end # constructor
+
+    # (see BaseMatcher#description)
+    def description
+      message = 'have errors'
+
+      attribute_messages = @error_expectations.select(&:expected).map do |expectation|
+        attribute_message = ":#{expectation.attribute}"
+
+        error_messages = expectation.messages.select(&:expected).map do |message_expectation|
+          %{"#{message_expectation.message}"}
+        end # map
+
+        unless error_messages.empty?
+          tools = ::SleepingKingStudios::Tools::ArrayTools
+
+          attribute_message <<
+            " with message#{error_messages.count == 1 ? '' : 's'} "\
+            "#{tools.humanize_list error_messages}"
+        end # unless
+
+        attribute_message
+      end # each
+      message << " on #{attribute_messages.join(", and on ")}" unless attribute_messages.empty?
+
+      message
+    end # method description
+
+    # Checks if the object can be validated, whether the object is valid, and
+    # checks the errors on the object against the expected errors and messages
+    # from #on and #with_message, if any.
+    #
+    # @param [Object] actual The object to test against the matcher.
+    #
+    # @return [Boolean] True if the object responds to :valid? and is valid
+    #   or object.errors does not match the specified errors and messages (if
+    #   any); otherwise false.
+    #
+    # @see #matches?
+    def does_not_match? actual
+      super
+
+      @negative_expectation = true
+
+      return false unless @validates = actual.respond_to?(:valid?)
+
+      !matches?(actual)
+    end # method does_not_match?
+
+    # Checks if the object can be validated, whether the object is valid, and
+    # checks the errors on the object against the expected errors and messages
+    # from #on and #with_message, if any.
+    #
+    # @param [Object] actual The object to test against the matcher.
+    #
+    # @return [Boolean] True if the object responds to :valid?, is not valid,
+    #   and object.errors matches the specified errors and messages (if any);
+    #   otherwise false.
+    #
+    # @see RSpec::SleepingKingStudios::Matchers::BaseMatcher#matches?
+    def matches? actual
+      super
+
+      return false unless @validates = actual.respond_to?(:valid?)
+
+      !@actual.valid? && attributes_have_errors?
+    end # method matches?
+
+    # Adds an error expectation. If the actual object does not have an error on
+    # the specified attribute, #matches? will return false.
+    #
+    # @param [String, Symbol] attribute
+    #
+    # @return [HaveErrorsMatcher] self
+    #
+    # @example Setting an error expectation
+    #   expect(actual).to have_errors.on(:foo)
+    def on attribute
+      @error_expectations << ErrorExpectation.new(attribute)
+
+      self
+    end # method on
+
+    # Adds a message expectation for the most recently added error attribute.
+    # If the actual object does not have an error on the that attribute with
+    # the specified message, #matches? will return false.
+    #
+    # @param [String, Regexp] message The expected error message. If a string,
+    #   matcher will check for an exact match; if a regular expression, matcher
+    #   will check if the message matches the regexp.
+    #
+    # @raise [ArgumentError] If no error attribute has been added.
+    #
+    # @return [HaveErrorsMatcher] self
+    #
+    # @example Setting an error and a message expectation
+    #   expect(actual).to have_errors.on(:foo).with("can't be blank")
+    #
+    # @see #on
+    def with_message message
+      raise ArgumentError.new "no attribute specified for error message" if
+        @error_expectations.empty?
+
+      @error_expectations.last.messages << MessageExpectation.new(message)
+
+      self
+    end # method with_message
+
+    # Adds a set of message expectations for the most recently added error
+    # attribute.
+    #
+    # @param [Array<String, Regexp>] messages
+    #
+    # @see #with_message
+    def with_messages *messages
+      messages.each do |message| self.with_message(message); end
+
+      self
+    end # method with_message
+    alias_method :with, :with_messages
+
+    # (see BaseMatcher#failure_message)
+    def failure_message
+      # Failure cases:
+      # * object is not a model ("to respond to valid")
+      # * expected one or more errors, but received none ("to have errors")
+      # * expected one or more messages on :attribute, but received none or a
+      #   subset ("to have errors on")
+
+      if !@validates
+        "expected #{@actual.inspect} to respond to :valid?"
+      elsif expected_errors.empty?
+        "expected #{@actual.inspect} to have errors"
+      else
+        "expected #{@actual.inspect} to have errors#{expected_errors_message}#{received_errors_message}"
+      end # if-elsif-else
+    end # method failure_message
+
+    # (see BaseMatcher#failure_message_when_negated)
+    def failure_message_when_negated
+      # Failure cases:
+      # * object is not a model ("to respond to valid")
+      # * expected one or more errors, received one or more ("not to have
+      #   errors")
+      # * expected one or more messages on attribute, received one or more
+      #   ("not to have errors on")
+      # * expected specific messages on attribute, received all ("not to have
+      #   errors on")
+
+      if !@validates
+        "expected #{@actual.inspect} to respond to :valid?"
+      elsif expected_errors.empty?
+        return "expected #{@actual.inspect} not to have errors#{received_errors_message}"
+      else
+        return "expected #{@actual.inspect} not to have errors#{expected_errors_message}#{received_errors_message}"
+      end # if-else
+    end # method failure_message_when_negated
+
+    private
+
+    def attributes_have_errors?
+      # Iterate through the received errors and match them against the expected
+      # errors and messages.
+      @actual.errors.messages.each do |attribute, messages|
+        # Find the matching error expectation, if any.
+        error_expectation = @error_expectations.detect do |error_expectation|
+          error_expectation.attribute == attribute
+        end # detect
+
+        if error_expectation
+          error_expectation.received = true
+
+          # If the error includes message expectations, iterate through the
+          # received messages.
+          unless error_expectation.messages.empty?
+            messages.each do |message|
+              # Find the matching message expectation, if any.
+              message_expectation = error_expectation.messages.detect do |message_expectation|
+                if Regexp === message_expectation.message
+                  message =~ message_expectation.message
+                else
+                  message == message_expectation.message
+                end # if-else
+              end # detect
+
+              if message_expectation
+                message_expectation.received = true
+              else
+                error_expectation.messages << MessageExpectation.new(message, false, true)
+              end # if-else
+            end # each
+          end # unless
+        else
+          error_expectation = ErrorExpectation.new attribute, false, true
+          messages.each do |message|
+            error_expectation.messages << MessageExpectation.new(message, false, true)
+          end # each
+
+          @error_expectations << error_expectation
+        end # if-else
+      end # each
+
+      missing_errors.empty? && missing_messages.empty?
+    end # method attributes_have_errors
+
+    def expected_errors
+      @error_expectations.select do |error_expectation|
+        error_expectation.expected
+      end # select
+    end # method expected_errors
+
+    def missing_errors
+      @error_expectations.select do |error_expectation|
+        error_expectation.expected && !error_expectation.received
+      end # select
+    end # method missing_errors
+
+    def missing_messages
+      @error_expectations.select do |error_expectation|
+        !error_expectation.messages.missing.empty?
+      end # select
+    end # method missing_messages
+
+    def unexpected_errors
+      @error_expectations.select do |error_expectation|
+        !error_expectation.expected && error_expectation.received
+      end # select
+    end # method unexpected_errors
+
+    def expected_errors_message
+      "\n  expected errors:" + expected_errors.map do |error_expectation|
+        "\n    #{error_expectation.attribute}: " + (error_expectation.messages.empty? ?
+          "(#{@negative_expectation ? 'none' : 'any'})" :
+          error_expectation.messages.expected.map(&:message).map(&:inspect).join(", "))
+      end.join # map
+    end # method expected_errors_message
+
+    def received_errors_message
+      return "" unless @validates
+
+      return "\n  received errors:\n    (none)" if @actual.errors.messages.empty?
+
+      "\n  received errors:" + @actual.errors.messages.map do |attr, ary|
+        "\n    #{attr}: " + ary.map(&:inspect).join(", ")
+      end.join # map
+    end # method received_errors_message
+  end # class
+end # module

data/lib/rspec/sleeping_king_studios/matchers/base_matcher.rb

@@ -1,21 +1,18 @@
 # lib/rspec/sleeping_king_studios/matchers/base_matcher.rb
 
 require 'rspec/sleeping_king_studios/matchers'
+require 'rspec/sleeping_king_studios/matchers/description'
+
+require 'sleeping_king_studios/tools/string_tools'
 
 module RSpec::SleepingKingStudios::Matchers
   # Minimal implementation of the RSpec matcher interface.
   #
   # @since 1.0.0
   class BaseMatcher
-    attr_reader :actual
+    include RSpec::SleepingKingStudios::Matchers::Description
 
-    # A short string that describes the purpose of the matcher.
-    #
-    # @return [String] the matcher description
-    def description
-      return name_to_sentence unless defined?(@expected)
-      "#{name_to_sentence}#{to_sentence @expected}"
-    end # method description
+    attr_reader :actual
 
     # Inverse of #matches? method.
     #
@@ -51,12 +48,5 @@ module RSpec::SleepingKingStudios::Matchers
     def failure_message_when_negated
       "expected #{@actual.inspect} not to #{description}"
     end # method failure_message_when_negated
-
-    private
-
-    # @api private
-    def name_to_sentence
-      'match'
-    end # method name_to_sentence
   end # class
 end # module

data/lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb

@@ -1,69 +1,9 @@
 # lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb
 
-require 'rspec/sleeping_king_studios/matchers/built_in'
-require 'sleeping_king_studios/tools/enumerable_tools'
+require 'rspec/sleeping_king_studios/matchers/built_in/be_kind_of_matcher'
+require 'rspec/sleeping_king_studios/matchers/macros'
 
-module RSpec::SleepingKingStudios::Matchers::BuiltIn
-  # Extensions to the built-in RSpec #be_kind_of matcher.
-  class BeAKindOfMatcher < RSpec::Matchers::BuiltIn::BeAKindOf
-    include SleepingKingStudios::Tools::EnumerableTools
-
-    # (see BaseMatcher#description)
-    def description
-      message = "be #{type_string}"
-    end # method description
-
-    # Checks if the object matches one of the specified types. Allows an
-    # expected value of nil as a shortcut for expecting an instance of
-    # NilClass.
-    #
-    # @param [Module, nil, Array<Module, nil>] expected The type or types to
-    #   check the object against.
-    # @param [Object] actual The object to check.
-    #
-    # @return [Boolean] True if the object matches one of the specified types,
-    #   otherwise false.
-    def match expected, actual
-      match_type? expected
-    end # method match
-
-    # (see BaseMatcher#failure_message)
-    def failure_message
-      "expected #{@actual.inspect} to be #{type_string}"
-    end # method failure_message
-
-    # (see BaseMatcher#failure_message_when_negated)
-    def failure_message_when_negated
-      "expected #{@actual.inspect} not to be #{type_string}"
-    end # method failure_message_when_negated
-
-    private
-
-    def match_type? expected
-      case
-      when expected.nil?
-        @actual.nil?
-      when expected.is_a?(Enumerable)
-        expected.reduce(false) { |memo, obj| memo || match_type?(obj) }
-      else
-        @actual.kind_of? expected
-      end # case
-    end # method match_type?
-
-    def type_string
-      case
-      when @expected.nil?
-        @expected.inspect
-      when @expected.is_a?(Enumerable) && 1 < @expected.count
-        "a #{humanize_list @expected.map { |value| value.nil? ? 'nil' : value }, :last_separator => ' or '}"
-      else
-        "a #{expected}"
-      end # case
-    end # method type_string
-  end # class
-end # module
-
-module RSpec::SleepingKingStudios::Matchers
+module RSpec::SleepingKingStudios::Matchers::Macros
   # @see RSpec::SleepingKingStudios::Matchers::BuiltIn::BeAKindOfMatcher#match
   def be_kind_of expected
     RSpec::SleepingKingStudios::Matchers::BuiltIn::BeAKindOfMatcher.new expected

data/lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of_matcher.rb

@@ -0,0 +1,65 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of_matcher.rb
+
+require 'rspec/sleeping_king_studios/matchers/built_in'
+require 'sleeping_king_studios/tools/array_tools'
+
+module RSpec::SleepingKingStudios::Matchers::BuiltIn
+  # Extensions to the built-in RSpec #be_kind_of matcher.
+  class BeAKindOfMatcher < RSpec::Matchers::BuiltIn::BeAKindOf
+    # (see BaseMatcher#description)
+    def description
+      message = "be #{type_string}"
+    end # method description
+
+    # Checks if the object matches one of the specified types. Allows an
+    # expected value of nil as a shortcut for expecting an instance of
+    # NilClass.
+    #
+    # @param [Module, nil, Array<Module, nil>] expected The type or types to
+    #   check the object against.
+    # @param [Object] actual The object to check.
+    #
+    # @return [Boolean] True if the object matches one of the specified types,
+    #   otherwise false.
+    def match expected, actual
+      match_type? expected
+    end # method match
+
+    # (see BaseMatcher#failure_message)
+    def failure_message
+      "expected #{@actual.inspect} to be #{type_string}"
+    end # method failure_message
+
+    # (see BaseMatcher#failure_message_when_negated)
+    def failure_message_when_negated
+      "expected #{@actual.inspect} not to be #{type_string}"
+    end # method failure_message_when_negated
+
+    private
+
+    def match_type? expected
+      case
+      when expected.nil?
+        @actual.nil?
+      when expected.is_a?(Enumerable)
+        expected.reduce(false) { |memo, obj| memo || match_type?(obj) }
+      else
+        @actual.kind_of? expected
+      end # case
+    end # method match_type?
+
+    def type_string
+      case
+      when @expected.nil?
+        @expected.inspect
+      when @expected.is_a?(Enumerable) && 1 < @expected.count
+        tools = ::SleepingKingStudios::Tools::ArrayTools
+        items = @expected.map { |value| value.nil? ? 'nil' : value }
+
+        "a #{tools.humanize_list items, :last_separator => ' or '}"
+      else
+        "a #{expected}"
+      end # case
+    end # method type_string
+  end # class
+end # module

data/lib/rspec/sleeping_king_studios/matchers/built_in/include.rb

@@ -1,114 +1,9 @@
 # lib/rspec/sleeping_king_studios/matchers/built_in/be_kind_of.rb
 
-require 'rspec/sleeping_king_studios/matchers/built_in'
+require 'rspec/sleeping_king_studios/matchers/built_in/include_matcher'
+require 'rspec/sleeping_king_studios/matchers/macros'
 
-module RSpec::SleepingKingStudios::Matchers::BuiltIn
-  # Extensions to the built-in RSpec #include matcher.
-  class IncludeMatcher < RSpec::Matchers::BuiltIn::Include
-    # @param [Array<Hash, Proc, Object>] expected the items expected to be
-    #   matched by the actual object
-    #
-    # @yield If a block is provided, the block is converted to a proc and
-    #   appended to the item expectations.
-    # @yieldparam [Object] item An item from the actual object; yield(item)
-    #   should return true if and only if the item matches the desired
-    #   predicate.
-    def initialize *expected, &block
-      expected << block if block_given?
-
-      super *expected
-    end # constructor
-
-    # @api private
-    #
-    # @return [Boolean]
-    def matches?(actual)
-      perform_match(actual) { |v| v }
-    end # method matches?
-
-    # @api private
-    #
-    # @return [Boolean]
-    def does_not_match?(actual)
-      perform_match(actual) { |v| !v }
-    end # method does_not_match?
-
-    # @api private
-    #
-    # Converts the expected item to a human-readable string. Retained for
-    # pre-3.3 compatibility.
-    def to_word expected_item
-      case
-      when is_matcher_with_description?(expected_item)
-        expected_item.description
-      when Proc === expected_item
-        "an item matching the block"
-      else
-        expected_item.inspect
-      end # case
-    end # method to_word
-
-    # (see BaseMatcher#failure_message)
-    def failure_message
-      message = super.sub ':__block_comparison__', 'an item matching the block'
-
-      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
-
-      message
-    end # method failure_message_for_should
-
-    # (see BaseMatcher#failure_message_when_negated)
-    def failure_message_when_negated
-      message = super.sub ':__block_comparison__', 'an item matching the block'
-
-      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
-
-      message
-    end # method
-
-    private
-
-    # @api private
-    def perform_match(actual, &block)
-      @actual = actual
-      @divergent_items = excluded_from_actual(&block)
-      actual.respond_to?(:include?) && @divergent_items.empty?
-    end # method perform_match
-
-    # @api private
-    def excluded_from_actual
-      return [] unless @actual.respond_to?(:include?)
-
-      expected.inject([]) do |memo, expected_item|
-        if comparing_proc?(expected_item)
-          memo << :__block_comparison__ unless yield actual_matches_proc?(expected_item)
-        elsif comparing_hash_to_a_subset?(expected_item)
-          expected_item.each do |(key, value)|
-            memo << { key => value } unless yield actual_hash_includes?(key, value)
-          end # each
-        elsif comparing_hash_keys?(expected_item)
-          memo << expected_item unless yield actual_hash_has_key?(expected_item)
-        else
-          memo << expected_item unless yield actual_collection_includes?(expected_item)
-        end # if-elsif-else
-
-        memo
-      end # inject
-    end # method excluded_from_actual
-
-    # @api private
-    def actual_matches_proc? expected_item
-      !!actual.detect(&expected_item)
-    end # method actual_matches_proc?
-
-    # @api private
-    def comparing_proc? expected_item
-      expected_item.is_a?(Proc)
-    end # method comparing_proc?
-  end # class
-end # module
-
-module RSpec::SleepingKingStudios::Matchers
+module RSpec::SleepingKingStudios::Matchers::Macros
   # @see RSpec::SleepingKingStudios::Matchers::BuiltIn::IncludeMatcher#matches?
   def include *expected, &block
     RSpec::SleepingKingStudios::Matchers::BuiltIn::IncludeMatcher.new *expected, &block

data/lib/rspec/sleeping_king_studios/matchers/built_in/include_matcher.rb

@@ -0,0 +1,134 @@
+# lib/rspec/sleeping_king_studios/matchers/built_in/include_matcher.rb
+
+require 'rspec/sleeping_king_studios/matchers/built_in'
+require 'rspec/sleeping_king_studios/matchers/description'
+
+module RSpec::SleepingKingStudios::Matchers::BuiltIn
+  # Extensions to the built-in RSpec #include matcher.
+  class IncludeMatcher < RSpec::Matchers::BuiltIn::Include
+    include RSpec::SleepingKingStudios::Matchers::Description
+
+    # @param [Array<Hash, Proc, Object>] expected the items expected to be
+    #   matched by the actual object
+    #
+    # @yield If a block is provided, the block is converted to a proc and
+    #   appended to the item expectations.
+    # @yieldparam [Object] item An item from the actual object; yield(item)
+    #   should return true if and only if the item matches the desired
+    #   predicate.
+    def initialize *expected, &block
+      expected << block if block_given?
+
+      super *expected
+    end # constructor
+
+    # (see BaseMatcher#description)
+    def description
+      desc = super
+
+      # Format hash expectations.
+      desc = desc.gsub(/(\S)=>(\S)/, '\1 => \2')
+
+      # Replace processed block expectation stub with proper description.
+      desc = desc.gsub ':__block_comparison__', 'an item matching the block'
+
+      desc
+    end # method description
+
+    # @api private
+    #
+    # @return [Boolean]
+    def matches?(actual)
+      @actual = actual
+
+      perform_match(actual) { |v| v }
+    end # method matches?
+
+    # @api private
+    #
+    # @return [Boolean]
+    def does_not_match?(actual)
+      @actual = actual
+
+      perform_match(actual) { |v| !v }
+    end # method does_not_match?
+
+    # (see BaseMatcher#failure_message)
+    def failure_message
+      message = super.sub ':__block_comparison__', 'an item matching the block'
+
+      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
+
+      message
+    end # method failure_message_for_should
+
+    # (see BaseMatcher#failure_message_when_negated)
+    def failure_message_when_negated
+      message = super.sub ':__block_comparison__', 'an item matching the block'
+
+      message << ", but it does not respond to `include?`" unless actual.respond_to?(:include?) || message =~ /does not respond to/
+
+      message
+    end # method
+
+    private
+
+    def actual_matches_proc? expected_item
+      if actual.respond_to?(:detect)
+        !!actual.detect(&expected_item)
+      else
+        !!expected_item.call(actual)
+      end # if-else
+    end # method actual_matches_proc?
+
+    def comparing_proc? expected_item
+      expected_item.is_a?(Proc)
+    end # method comparing_proc?
+
+    def excluded_from_actual
+      return [] unless @actual.respond_to?(:include?)
+
+      expected.inject([]) do |memo, expected_item|
+        if comparing_proc?(expected_item)
+          memo << :__block_comparison__ unless yield actual_matches_proc?(expected_item)
+        elsif comparing_hash_to_a_subset?(expected_item)
+          expected_item.each do |(key, value)|
+            memo << { key => value } unless yield actual_hash_includes?(key, value)
+          end # each
+        elsif comparing_hash_keys?(expected_item)
+          memo << expected_item unless yield actual_hash_has_key?(expected_item)
+        else
+          memo << expected_item unless yield actual_collection_includes?(expected_item)
+        end # if-elsif-else
+
+        memo
+      end # inject
+    end # method excluded_from_actual
+
+    def expected_items_for_description
+      # Preprocess items to stub out block expectations.
+      @expected.map { |item| item.is_a?(Proc) ? :__block_comparison__ : item }
+    end # method expected_items_for_description
+
+    def perform_match(actual, &block)
+      @actual = actual
+      @divergent_items = excluded_from_actual(&block)
+      actual.respond_to?(:include?) && @divergent_items.empty?
+    end # method perform_match
+
+    # @api private
+    #
+    # Converts the expected item to a human-readable string. Retained for
+    # pre-3.3 compatibility.
+    def to_word expected_item
+      case
+      when is_matcher_with_description?(expected_item)
+        expected_item.description
+      when Proc === expected_item
+        "an item matching the block"
+      else
+        expected_item.inspect
+      end # case
+    end # method to_word
+  end # class
+end # module