shoulda-matchers 3.0.1 → 3.1.0

data/lib/shoulda/matchers/active_model/qualifiers/ignoring_interference_by_writer.rb

@@ -0,0 +1,21 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module IgnoringInterferenceByWriter
+          attr_reader :ignore_interference_by_writer
+
+          def initialize(*args)
+            @ignore_interference_by_writer = IgnoreInterferenceByWriter.new
+          end
+
+          def ignoring_interference_by_writer(value = :always)
+            @ignore_interference_by_writer.set(value)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/validate_absence_of_matcher.rb

@@ -4,21 +4,21 @@ module Shoulda
       # The `validate_absence_of` matcher tests the usage of the
       # `validates_absence_of` validation.
       #
-      #     class Artillery
+      #     class PowerHungryCountry
       #       include ActiveModel::Model
-      #       attr_accessor :arms
+      #       attr_accessor :nuclear_weapons
       #
-      #       validates_absence_of :arms
+      #       validates_absence_of :nuclear_weapons
       #     end
       #
       #     # RSpec
-      #     describe Artillery do
-      #       it { should validate_absence_of(:arms) }
+      #     describe PowerHungryCountry do
+      #       it { should validate_absence_of(:nuclear_weapons) }
       #     end
       #
       #     # Minitest (Shoulda)
-      #     class ArtilleryTest < ActiveSupport::TestCase
-      #       should validate_absence_of(:arms)
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons)
       #     end
       #
       # #### Qualifiers
@@ -27,47 +27,47 @@ module Shoulda
       #
       # Use `on` if your validation applies only under a certain context.
       #
-      #     class Artillery
+      #     class PowerHungryCountry
       #       include ActiveModel::Model
-      #       attr_accessor :arms
+      #       attr_accessor :nuclear_weapons
       #
-      #       validates_absence_of :arms, on: :create
+      #       validates_absence_of :nuclear_weapons, on: :create
       #     end
       #
       #     # RSpec
-      #     describe Artillery do
-      #       it { should validate_absence_of(:arms).on(:create) }
+      #     describe PowerHungryCountry do
+      #       it { should validate_absence_of(:nuclear_weapons).on(:create) }
       #     end
       #
       #     # Minitest (Shoulda)
-      #     class ArtilleryTest < ActiveSupport::TestCase
-      #       should validate_absence_of(:arms).on(:create)
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons).on(:create)
       #     end
       #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
       #
-      #     class Artillery
+      #     class PowerHungryCountry
       #       include ActiveModel::Model
-      #       attr_accessor :arms
+      #       attr_accessor :nuclear_weapons
       #
-      #       validates_absence_of :arms,
-      #         message: "We're fresh outta arms here, soldier!"
+      #       validates_absence_of :nuclear_weapons,
+      #         message: "there shall be peace on Earth"
       #     end
       #
       #     # RSpec
-      #     describe Artillery do
+      #     describe PowerHungryCountry do
       #       it do
-      #         should validate_absence_of(:arms).
-      #           with_message("We're fresh outta arms here, soldier!")
+      #         should validate_absence_of(:nuclear_weapons).
+      #           with_message("there shall be peace on Earth")
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
-      #     class ArtilleryTest < ActiveSupport::TestCase
-      #       should validate_absence_of(:arms).
-      #         with_message("We're fresh outta arms here, soldier!")
+      #     class PowerHungryCountryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:nuclear_weapons).
+      #         with_message("there shall be peace on Earth")
       #     end
       #
       # @return [ValidateAbsenceOfMatcher}
@@ -78,20 +78,18 @@ module Shoulda
 
       # @private
       class ValidateAbsenceOfMatcher < ValidationMatcher
-        def with_message(message)
-          @expected_message = message
-          self
+        def initialize(attribute)
+          super
+          @expected_message = :present
         end
 
         def matches?(subject)
           super(subject)
-          @expected_message ||= :present
-
           disallows_value_of(value, @expected_message)
         end
 
-        def description
-          "require #{@attribute} to not be set"
+        def simple_description
+          "validate that :#{@attribute} is empty/falsy"
         end
 
         private
@@ -110,7 +108,7 @@ module Shoulda
             when :decimal then BigDecimal.new(1, 0)
             when :datetime, :time, :timestamp then Time.now
             when :date then Date.new
-            when :binary then "0"
+            when :binary then '0'
             else 'an arbitrary value'
             end
           end

data/lib/shoulda/matchers/active_model/validate_acceptance_of_matcher.rb

@@ -81,21 +81,18 @@ module Shoulda
 
       # @private
       class ValidateAcceptanceOfMatcher < ValidationMatcher
-        def with_message(message)
-          if message
-            @expected_message = message
-          end
-          self
+        def initialize(attribute)
+          super
+          @expected_message = :accepted
         end
 
         def matches?(subject)
           super(subject)
-          @expected_message ||= :accepted
           disallows_value_of(false, @expected_message)
         end
 
-        def description
-          "require #{@attribute} to be accepted"
+        def simple_description
+          %(validate that :#{@attribute} has been set to "1")
         end
       end
     end

data/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -83,22 +83,17 @@ module Shoulda
         attr_reader :attribute, :confirmation_attribute
 
         def initialize(attribute)
-          super(attribute)
+          super
+          @expected_message = :confirmation
           @confirmation_attribute = "#{attribute}_confirmation"
         end
 
-        def with_message(message)
-          @message = message if message
-          self
-        end
-
-        def description
-          "require #{@confirmation_attribute} to match #{@attribute}"
+        def simple_description
+          "validate that :#{@confirmation_attribute} matches :#{@attribute}"
         end
 
         def matches?(subject)
           super(subject)
-          @message ||= :confirmation
 
           disallows_different_value &&
             allows_same_value &&
@@ -108,38 +103,43 @@ module Shoulda
         private
 
         def disallows_different_value
-          set_confirmation('some value')
           disallows_value_of('different value') do |matcher|
-            qualify_matcher(matcher)
+            qualify_matcher(matcher, 'some value')
           end
         end
 
         def allows_same_value
-          set_confirmation('same value')
           allows_value_of('same value') do |matcher|
-            qualify_matcher(matcher)
+            qualify_matcher(matcher, 'same value')
           end
         end
 
         def allows_missing_confirmation
-          set_confirmation(nil)
           allows_value_of('any value') do |matcher|
-            qualify_matcher(matcher)
+            qualify_matcher(matcher, nil)
           end
         end
 
-        def qualify_matcher(matcher)
-          matcher.with_message(@message,
+        def qualify_matcher(matcher, confirmation_attribute_value)
+          matcher.values_to_preset = {
+            confirmation_attribute => confirmation_attribute_value
+          }
+          matcher.with_message(
+            @expected_message,
             against: confirmation_attribute,
             values: { attribute: attribute }
           )
         end
 
-        def set_confirmation(val)
-          setter = :"#{@confirmation_attribute}="
-          if @subject.respond_to?(setter)
-            @subject.__send__(setter, val)
-          end
+        def set_confirmation(value)
+          @last_value_set_on_confirmation_attribute = value
+
+          AttributeSetter.set(
+            matcher_name: 'confirmation',
+            object: @subject,
+            attribute_name: confirmation_attribute,
+            value: value
+          )
         end
       end
     end

data/lib/shoulda/matchers/active_model/validate_exclusion_of_matcher.rb

@@ -122,9 +122,9 @@ module Shoulda
       class ValidateExclusionOfMatcher < ValidationMatcher
         def initialize(attribute)
           super(attribute)
+          @expected_message = :exclusion
           @array = nil
           @range = nil
-          @expected_message = nil
         end
 
         def in_array(array)
@@ -139,13 +139,21 @@ module Shoulda
           self
         end
 
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
+        def simple_description
+          if @range
+            "validate that :#{@attribute} lies outside the range " +
+              Shoulda::Matchers::Util.inspect_range(@range)
+          else
+            description = "validate that :#{@attribute}"
+
+            if @array.many?
+              description << " is neither #{inspected_array}"
+            else
+              description << " is not #{inspected_array}"
+            end
 
-        def description
-          "ensure exclusion of #{@attribute} in #{inspect_message}"
+            description
+          end
         end
 
         def matches?(subject)
@@ -165,28 +173,24 @@ module Shoulda
 
         def disallows_all_values_in_array?
           @array.all? do |value|
-            disallows_value_of(value, expected_message)
+            disallows_value_of(value, @expected_message)
           end
         end
 
         def allows_lower_value
-          @minimum == 0 || allows_value_of(@minimum - 1, expected_message)
+          @minimum == 0 || allows_value_of(@minimum - 1, @expected_message)
         end
 
         def allows_higher_value
-          allows_value_of(@maximum + 1, expected_message)
+          allows_value_of(@maximum + 1, @expected_message)
         end
 
         def disallows_minimum_value
-          disallows_value_of(@minimum, expected_message)
+          disallows_value_of(@minimum, @expected_message)
         end
 
         def disallows_maximum_value
-          disallows_value_of(@maximum, expected_message)
-        end
-
-        def expected_message
-          @expected_message || :exclusion
+          disallows_value_of(@maximum, @expected_message)
         end
 
         def inspect_message
@@ -196,6 +200,13 @@ module Shoulda
             @array.inspect
           end
         end
+
+        def inspected_array
+          Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
+            two_words_connector: " nor ",
+            last_word_connector: ", nor "
+          )
+        end
       end
     end
   end

data/lib/shoulda/matchers/active_model/validate_inclusion_of_matcher.rb

@@ -13,21 +13,22 @@ module Shoulda
       #       include ActiveModel::Model
       #       attr_accessor :state
       #
-      #       validates_inclusion_of :state, in: %w(open resolved unresolved)
+      #       validates_inclusion_of :state,
+      #         in: ['open', 'resolved', 'unresolved']
       #     end
       #
       #     # RSpec
       #     describe Issue do
       #       it do
       #         should validate_inclusion_of(:state).
-      #           in_array(%w(open resolved unresolved))
+      #           in_array(['open', 'resolved', 'unresolved'])
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
       #     class IssueTest < ActiveSupport::TestCase
       #       should validate_inclusion_of(:state).
-      #         in_array(%w(open resolved unresolved))
+      #         in_array(['open', 'resolved', 'unresolved'])
       #     end
       #
       # If your whitelist is a range of values, use `in_range`:
@@ -57,7 +58,10 @@ module Shoulda
       # one of these three values. That means there isn't any way we can refute
       # this logic in a test. Hence, this will produce a warning:
       #
-      #     it { should validate_inclusion_of(:imported).in_array([true, false]) }
+      #     it do
+      #       should validate_inclusion_of(:imported).
+      #         in_array([true, false])
+      #     end
       #
       # The only case where `validate_inclusion_of` *could* be appropriate is
       # for ensuring that a boolean column accepts nil, but we recommend
@@ -205,7 +209,7 @@ module Shoulda
       #
       #       validates_presence_of :state
       #       validates_inclusion_of :state,
-      #         in: %w(open resolved unresolved),
+      #         in: ['open', 'resolved', 'unresolved'],
       #         allow_nil: true
       #     end
       #
@@ -213,7 +217,7 @@ module Shoulda
       #     describe Issue do
       #       it do
       #         should validate_inclusion_of(:state).
-      #           in_array(%w(open resolved unresolved)).
+      #           in_array(['open', 'resolved', 'unresolved']).
       #           allow_nil
       #       end
       #     end
@@ -221,7 +225,7 @@ module Shoulda
       #     # Minitest (Shoulda)
       #     class IssueTest < ActiveSupport::TestCase
       #       should validate_inclusion_of(:state).
-      #         in_array(%w(open resolved unresolved)).
+      #         in_array(['open', 'resolved', 'unresolved']).
       #         allow_nil
       #     end
       #
@@ -235,7 +239,7 @@ module Shoulda
       #
       #       validates_presence_of :state
       #       validates_inclusion_of :state,
-      #         in: %w(open resolved unresolved),
+      #         in: ['open', 'resolved', 'unresolved'],
       #         allow_blank: true
       #     end
       #
@@ -243,7 +247,7 @@ module Shoulda
       #     describe Issue do
       #       it do
       #         should validate_inclusion_of(:state).
-      #           in_array(%w(open resolved unresolved)).
+      #           in_array(['open', 'resolved', 'unresolved']).
       #           allow_blank
       #       end
       #     end
@@ -251,7 +255,7 @@ module Shoulda
       #     # Minitest (Shoulda)
       #     class IssueTest < ActiveSupport::TestCase
       #       should validate_inclusion_of(:state).
-      #         in_array(%w(open resolved unresolved)).
+      #         in_array(['open', 'resolved', 'unresolved']).
       #         allow_blank
       #     end
       #
@@ -310,31 +314,61 @@ EOT
           self
         end
 
+        def expects_to_allow_blank?
+          @options[:allow_blank]
+        end
+
         def allow_nil(allow_nil = true)
           @options[:allow_nil] = allow_nil
           self
         end
 
+        def expects_to_allow_nil?
+          @options[:allow_nil]
+        end
+
         def with_message(message)
           if message
+            @expects_custom_validation_message = true
             @low_message = message
             @high_message = message
           end
+
           self
         end
 
         def with_low_message(message)
-          @low_message = message if message
+          if message
+            @expects_custom_validation_message = true
+            @low_message = message
+          end
+
           self
         end
 
         def with_high_message(message)
-          @high_message = message if message
+          if message
+            @high_message = message
+          end
+
           self
         end
 
-        def description
-          "ensure inclusion of #{@attribute} in #{inspect_message}"
+        def simple_description
+          if @range
+            "validate that :#{@attribute} lies inside the range " +
+              Shoulda::Matchers::Util.inspect_range(@range)
+          else
+            description = "validate that :#{@attribute}"
+
+            if @array.many?
+              description << " is either #{inspected_array}"
+            else
+              description << " is #{inspected_array}"
+            end
+
+            description
+          end
         end
 
         def matches?(subject)
@@ -398,7 +432,9 @@ EOT
         end
 
         def disallows_lower_value
-          @minimum == 0 || disallows_value_of(@minimum - 1, @low_message)
+          @minimum.nil? ||
+            @minimum == 0 ||
+            disallows_value_of(@minimum - 1, @low_message)
         end
 
         def disallows_higher_value
@@ -518,6 +554,13 @@ EOT
             else :unknown
           end
         end
+
+        def inspected_array
+          Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
+            two_words_connector: " or ",
+            last_word_connector: ", or "
+          )
+        end
       end
     end
   end