rspec-sleeping_king_studios 2.1.1 → 2.2.0.rc.1

data/lib/rspec/sleeping_king_studios/examples/property_examples.rb

@@ -2,6 +2,9 @@
 
 require 'rspec/sleeping_king_studios/concerns/shared_example_group'
 require 'rspec/sleeping_king_studios/examples'
+require 'rspec/sleeping_king_studios/matchers/core/have_constant'
+require 'rspec/sleeping_king_studios/matchers/core/have_predicate'
+require 'rspec/sleeping_king_studios/matchers/core/have_property'
 require 'rspec/sleeping_king_studios/matchers/core/have_reader'
 require 'rspec/sleeping_king_studios/matchers/core/have_writer'
 require 'sleeping_king_studios/tools/object_tools'
@@ -15,50 +18,135 @@ module RSpec::SleepingKingStudios::Examples::PropertyExamples
   #
   # Internal object used to differentiate a nil expectation from a default
   # value expectation.
-  UNDEFINED_PROPERTY_EXPECTATION = Object.new.freeze
+  UNDEFINED_VALUE_EXPECTATION = Object.new.freeze
 
-  shared_examples 'has reader' do |property, expected_value = UNDEFINED_PROPERTY_EXPECTATION|
-    it "has reader :#{property}" do
-      object = defined?(instance) ? instance : subject
+  private def format_expected_value expected_value
+    if expected_value.is_a?(Proc)
+      object_tools = SleepingKingStudios::Tools::ObjectTools
+
+      if 0 == expected_value.arity
+        comparable_value = object_tools.apply self, expected_value
+      else
+        comparable_value = satisfy do |actual_value|
+          object_tools.apply self, expected_value, actual_value
+        end # satisfy
+      end # if-else
+    else
+      comparable_value = expected_value
+    end # if
+
+    comparable_value
+  end # method format_expected_value
+
+  shared_examples 'should have constant' do |constant_name, expected_value = UNDEFINED_VALUE_EXPECTATION|
+    it "should have constant :#{constant_name}" do
+      if defined?(described_class) && described_class.is_a?(Module)
+        object = described_class
+      else
+        object = subject
+      end # if-else
+
+      if expected_value == UNDEFINED_VALUE_EXPECTATION
+        expect(object).to have_constant(constant_name)
+      else
+        expected_value = format_expected_value(expected_value)
 
-      expect(object).to have_reader(property)
+        expect(object).to have_constant(constant_name).with_value(expected_value)
+      end # if-else
+    end # it
+  end # shared_examples
 
-      next if expected_value == UNDEFINED_PROPERTY_EXPECTATION
+  shared_examples 'should have immutable constant' do |constant_name, expected_value = UNDEFINED_VALUE_EXPECTATION|
+    it "should have immutable constant :#{constant_name}" do
+      if defined?(described_class) && described_class.is_a?(Module)
+        object = described_class
+      else
+        object = subject
+      end # if-else
 
-      actual_value = instance.send property
+      if expected_value == UNDEFINED_VALUE_EXPECTATION
+        expect(object).to have_immutable_constant(constant_name)
+      else
+        expected_value = format_expected_value(expected_value)
 
-      if expected_value.is_a?(Proc)
-        args = [self, expected_value]
-        args.push actual_value unless 0 == expected_value.arity
+        expect(object).to have_immutable_constant(constant_name).with_value(expected_value)
+      end # if-else
+    end # it
+  end # shared_examples
 
-        expected_value = SleepingKingStudios::Tools::ObjectTools.apply *args
-      end # if
+  shared_examples 'should have predicate' do |property, expected_value = UNDEFINED_VALUE_EXPECTATION|
+    it "should have predicate :#{property}?" do
+      object = defined?(instance) ? instance : subject
 
-      case expected_value
-      when ->(obj) { obj.respond_to?(:matches?) }
-        expect(actual_value).to expected_value
-      when true, false
-        expected_value
+      if expected_value == UNDEFINED_VALUE_EXPECTATION
+        expect(object).to have_predicate(property)
       else
-        expect(actual_value).to be == expected_value
-      end # case
+        expected_value = format_expected_value(expected_value)
+
+        expect(object).to have_predicate(property).with_value(expected_value)
+      end # if-else
     end # it
   end # shared_examples
-  alias_shared_examples 'should have reader', 'has reader'
+  alias_shared_examples 'has predicate', 'should have predicate'
 
-  shared_examples 'has writer' do |property|
-    it "has writer :#{property}=" do
+  shared_examples 'should have reader' do |property, expected_value = UNDEFINED_VALUE_EXPECTATION|
+    it "should have reader :#{property}" do
+      object = defined?(instance) ? instance : subject
+
+      if expected_value == UNDEFINED_VALUE_EXPECTATION
+        expect(object).to have_reader(property)
+      else
+        expected_value = format_expected_value(expected_value)
+
+        expect(object).to have_reader(property).with_value(expected_value)
+      end # if-else
+    end # it
+  end # shared_examples
+  alias_shared_examples 'has reader', 'should have reader'
+
+  shared_examples 'should not have reader' do |property|
+    it "should not have reader :#{property}" do
+      object = defined?(instance) ? instance : subject
+
+      expect(object).not_to have_reader(property)
+    end # it
+  end # shared_examples
+  alias_shared_examples 'does not have reader', 'should not have reader'
+
+  shared_examples 'should have writer' do |property|
+    property_name = property.to_s.sub /\=\z/, ''
+
+    it "should have writer :#{property_name}=" do
       object = defined?(instance) ? instance : subject
 
       expect(object).to have_writer(property)
     end # it
   end # shared_examples
-  alias_shared_examples 'should have writer', 'has writer'
+  alias_shared_examples 'has writer', 'should have writer'
 
-  shared_examples 'has property' do |property, expected_value = UNDEFINED_PROPERTY_EXPECTATION|
-    include_examples 'has reader', property, expected_value
+  shared_examples 'should not have writer' do |property|
+    property_name = property.to_s.sub /\=\z/, ''
 
-    include_examples 'has writer', property
+    it "should not have writer :#{property}=" do
+      object = defined?(instance) ? instance : subject
+
+      expect(object).not_to have_writer(property)
+    end # it
+  end # shared_examples
+  alias_shared_examples 'does not have writer', 'should not have writer'
+
+  shared_examples 'should have property' do |property, expected_value = UNDEFINED_VALUE_EXPECTATION|
+    it "should have property :#{property}" do
+      object = defined?(instance) ? instance : subject
+
+      if expected_value == UNDEFINED_VALUE_EXPECTATION
+        expect(object).to have_property(property)
+      else
+        expected_value = format_expected_value(expected_value)
+
+        expect(object).to have_property(property).with_value(expected_value)
+      end # if-else
+    end # it
   end # shared_examples
-  alias_shared_examples 'should have property', 'has property'
+  alias_shared_examples 'has property', 'should have property'
 end # module

data/lib/rspec/sleeping_king_studios/examples/rspec_matcher_examples.rb

@@ -8,54 +8,74 @@ require 'rspec/sleeping_king_studios/matchers/base_matcher'
 module RSpec::SleepingKingStudios::Examples::RSpecMatcherExamples
   extend RSpec::SleepingKingStudios::Concerns::SharedExampleGroup
 
-  shared_examples 'passes with a positive expectation' do
+  private def config
+    RSpec.configuration.sleeping_king_studios
+  end # method config
+
+  private def compare_message actual, expected
+    case expected
+    when String
+      if config.examples.match_string_failure_message_as == :exact
+        expect(actual).to be == expected
+      else
+        expect(actual).to include expected
+      end # if-else
+    when Regexp
+      expect(actual).to be =~ expected
+    when ->(obj) { obj.respond_to?(:matches?) && obj.respond_to?(:failure_message) }
+      expect(actual).to expected
+    else
+      expect(actual).to match expected
+    end # when
+  end # method compare_message
+
+  private def handle_missing_failure_message message
+    case config.examples.handle_missing_failure_message_with
+    when :pending
+      skip message
+    when :exception
+      raise StandardError.new message
+    end # case
+  end # method handle_missing_failure_message
+
+  shared_examples 'should pass with a positive expectation' do
     let(:matcher_being_examined) { defined?(instance) ? instance : subject }
 
-    it 'passes with a positive expectation' do
+    it 'should pass with positive expectation' do
       expect(matcher_being_examined.matches? actual).to be true
     end # it
   end # shared_examples
-  alias_shared_examples 'should pass with a positive expectation', 'passes with a positive expectation'
+  alias_shared_examples 'passes with a positive expectation', 'should pass with a positive expectation'
 
-  shared_examples 'fails with a positive expectation' do
+  shared_examples 'should fail with a positive expectation' do
     let(:matcher_being_examined) { defined?(instance) ? instance : subject }
 
-    it 'fails with a positive expectation' do
+    it 'should fail with a positive expectation' do
       expect(matcher_being_examined.matches? actual).to be false
     end # it
 
-    it 'has a failure message with a positive expectation' do
+    it 'should have a failure message with a positive expectation' do
       if defined?(failure_message)
         matcher_being_examined.matches?(actual)
 
-        expected = failure_message.is_a?(String) ?
-          Regexp.new(Regexp.escape(failure_message)) :
-          failure_message
-
-        expect(matcher_being_examined.failure_message).to match expected
+        compare_message(matcher_being_examined.failure_message, failure_message)
       else
-        message = <<-MESSAGE
-          expected to match #{matcher_being_examined.class}#failure_message, but the expected
-          value was undefined. Define a failure message using
-          let(:failure_message) or set
-          config.handle_missing_failure_message_with to :ignore or :pending.
-        MESSAGE
-        message = message.split("\n").map(&:strip).join(' ')
-        case RSpec.configuration.sleeping_king_studios.examples.handle_missing_failure_message_with
-        when :pending
-          skip message
-        when :exception
-          raise StandardError.new message
-        end # case
+        message =
+          "expected to match #{matcher_being_examined.class}#failure_message, "\
+          "but the expected value was undefined. Define a failure message "\
+          "using let(:failure_message) or set "\
+          "config.handle_missing_failure_message_with to :ignore or :pending."
+
+        handle_missing_failure_message(message)
       end # if
     end # it
   end # shared_examples
-  alias_shared_examples 'should fail with a positive expectation', 'fails with a positive expectation'
+  alias_shared_examples 'fails with a positive expectation', 'should fail with a positive expectation'
 
-  shared_examples 'passes with a negative expectation' do
+  shared_examples 'should pass with a negative expectation' do
     let(:matcher_being_examined) { defined?(instance) ? instance : subject }
 
-    it 'passes with a negative expectation' do
+    it 'should pass with a negative expectation' do
       if matcher_being_examined.respond_to?(:does_not_match?)
         expect(matcher_being_examined.does_not_match? actual).to be true
       else
@@ -63,12 +83,12 @@ module RSpec::SleepingKingStudios::Examples::RSpecMatcherExamples
       end # if-else
     end # it
   end # shared_examples
-  alias_shared_examples 'should pass with a negative expectation', 'passes with a negative expectation'
+  alias_shared_examples 'passes with a negative expectation', 'should pass with a negative expectation'
 
-  shared_examples 'fails with a negative expectation' do
+  shared_examples 'should fail with a negative expectation' do
     let(:matcher_being_examined) { defined?(instance) ? instance : subject }
 
-    it 'fails with a negative expectation' do
+    it 'should fail with a negative expectation' do
       if matcher_being_examined.respond_to?(:does_not_match?)
         expect(matcher_being_examined.does_not_match? actual).to be false
       else
@@ -76,31 +96,26 @@ module RSpec::SleepingKingStudios::Examples::RSpecMatcherExamples
       end # if-else
     end # it
 
-    it 'has a failure message with a negative expectation' do
+    it 'should have a failure message with a negative expectation' do
       if defined?(failure_message_when_negated)
-        matcher_being_examined.respond_to?(:does_not_match?) ? matcher_being_examined.does_not_match?(actual) : matcher_being_examined.matches?(actual)
-
-        expected = failure_message_when_negated.is_a?(String) ?
-          Regexp.new(Regexp.escape(failure_message_when_negated)) :
-          failure_message_when_negated
+        if matcher_being_examined.respond_to?(:does_not_match?)
+          matcher_being_examined.does_not_match?(actual)
+        else
+          matcher_being_examined.matches?(actual)
+        end # if-else
 
-        expect(matcher_being_examined.failure_message_when_negated).to match expected
+        compare_message(matcher_being_examined.failure_message_when_negated, failure_message_when_negated)
       else
-        message = <<-MESSAGE
-          expected to match #{matcher_being_examined.class}#failure_message_when_negated, but
-          the expected value was undefined. Define a failure message using
-          let(:failure_message_when_negated) or set
-          config.handle_missing_failure_message_with to :ignore or :pending.
-        MESSAGE
-        message = message.split("\n").map(&:strip).join(' ')
-        case RSpec.configuration.sleeping_king_studios.examples.handle_missing_failure_message_with
-        when :pending
-          skip message
-        when :exception
-          raise StandardError.new message
-        end # case
+        message =
+          "expected to match #{matcher_being_examined.class}#"\
+          "failure_message_when_negated, but the expected value was undefined."\
+          " Define a failure message using let(:failure_message_when_negated) "\
+          "or set config.handle_missing_failure_message_with to :ignore or "\
+          ":pending."
+
+        handle_missing_failure_message(message)
       end # if
     end # it
   end # shared_examples
-  alias_shared_examples 'should fail with a negative expectation', 'fails with a negative expectation'
+  alias_shared_examples 'fails with a negative expectation', 'should fail with a negative expectation'
 end # module

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

@@ -1,272 +1,11 @@
 # lib/rspec/sleeping_king_studios/matchers/active_model/have_errors.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/enumerable_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
-    include SleepingKingStudios::Tools::EnumerableTools
-    include SleepingKingStudios::Tools::StringTools
-
-    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?
-          attribute_message << " with #{pluralize(error_messages.count, 'message', 'messages')} #{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
-      @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
-
-  module RSpec::SleepingKingStudios::Matchers
-    # @see RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrorsMatcher#matches?
-    def have_errors
-      RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrorsMatcher.new
-    end # method have_errors
-  end # module
+require 'rspec/sleeping_king_studios/matchers/active_model/have_errors_matcher'
+require 'rspec/sleeping_king_studios/matchers/macros'
+
+module RSpec::SleepingKingStudios::Matchers::Macros
+  # @see RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrorsMatcher#matches?
+  def have_errors
+    RSpec::SleepingKingStudios::Matchers::ActiveModel::HaveErrorsMatcher.new
+  end # method have_errors
 end # module