mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,46 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class DisallowValueMatcher
+        def initialize(value)
+          @allow_matcher = AllowValueMatcher.new(value)
+        end
+
+        def matches?(subject)
+          !@allow_matcher.matches?(subject)
+        end
+
+        def for(attribute)
+          @allow_matcher.for(attribute)
+          self
+        end
+
+        def on(context)
+          @allow_matcher.on(context)
+          self
+        end
+
+        def with_message(message, options={})
+          @allow_matcher.with_message(message, options)
+          self
+        end
+
+        def failure_message
+          @allow_matcher.failure_message_when_negated
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          @allow_matcher.failure_message
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def strict
+          @allow_matcher.strict
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `ensure_exclusion_of` matcher tests usage of the
+      # `validates_exclusion_of` validation, asserting that an attribute cannot
+      # take a blacklist of values, and inversely, can take values outside of
+      # this list.
+      #
+      # #### Qualifiers
+      #
+      # `in_array` or `in_range` are used to test usage of the `:in` option,
+      # and so one must be used.
+      #
+      # ##### in_array
+      #
+      # Use `in_array` if your blacklist is an array of values.
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #
+      #       validates_exclusion_of :supported_os, in: ['Mac', 'Linux']
+      #     end
+      #
+      #     # RSpec
+      #     describe Game do
+      #       it { should ensure_exclusion_of(:supported_os).in_array(['Mac', 'Linux']) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class GameTest < ActiveSupport::TestCase
+      #       should ensure_exclusion_of(:supported_os).in_array(['Mac', 'Linux'])
+      #     end
+      #
+      # ##### in_range
+      #
+      # Use `in_range` if your blacklist is a range of values.
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #
+      #       validates_exclusion_of :supported_os, in: ['Mac', 'Linux']
+      #     end
+      #
+      #     # RSpec
+      #     describe Game do
+      #       it { should ensure_exclusion_of(:floors_with_enemies).in_range(5..8) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class GameTest < ActiveSupport::TestCase
+      #       should ensure_exclusion_of(:floors_with_enemies).in_range(5..8)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Game
+      #       validates_exclusion_of :weapon,
+      #         in: ['pistol', 'paintball gun', 'stick'],
+      #         message: 'You chose a puny weapon'
+      #     end
+      #
+      #     # RSpec
+      #     describe Game do
+      #       it do
+      #         should ensure_exclusion_of(:weapon).
+      #           in_array(['pistol', 'paintball gun', 'stick']).
+      #           with_message('You chose a puny weapon')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class GameTest < ActiveSupport::TestCase
+      #       should ensure_exclusion_of(:weapon).
+      #         in_array(['pistol', 'paintball gun', 'stick']).
+      #         with_message('You chose a puny weapon')
+      #     end
+      #
+      # @return [EnsureExclusionOfMatcher]
+      #
+      def ensure_exclusion_of(attr)
+        EnsureExclusionOfMatcher.new(attr)
+      end
+
+      # @private
+      class EnsureExclusionOfMatcher < ValidationMatcher
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = range.first
+          @maximum = range.max
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message if message
+          self
+        end
+
+        def description
+          "ensure exclusion of #{@attribute} in #{inspect_message}"
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            allows_lower_value &&
+              disallows_minimum_value &&
+              allows_higher_value &&
+              disallows_maximum_value
+          elsif @array
+            disallows_all_values_in_array?
+          end
+        end
+
+        private
+
+        def disallows_all_values_in_array?
+          @array.all? do |value|
+            disallows_value_of(value, expected_message)
+          end
+        end
+
+        def allows_lower_value
+          @minimum == 0 || allows_value_of(@minimum - 1, expected_message)
+        end
+
+        def allows_higher_value
+          allows_value_of(@maximum + 1, expected_message)
+        end
+
+        def disallows_minimum_value
+          disallows_value_of(@minimum, expected_message)
+        end
+
+        def disallows_maximum_value
+          disallows_value_of(@maximum, expected_message)
+        end
+
+        def expected_message
+          @expected_message || :exclusion
+        end
+
+        def inspect_message
+          if @range
+            @range.inspect
+          else
+            @array.inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,417 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `ensure_inclusion_of` matcher tests usage of the
+      # `validates_inclusion_of` validation, asserting that an attribute can
+      # take a whitelist of values and cannot take values outside of this list.
+      #
+      # #### Qualifiers
+      #
+      # `in_array` or `in_range` are used to test usage of the `:in` option,
+      # and so one must be used.
+      #
+      # ##### in_array
+      #
+      # Use `in_array` if your whitelist is an array of values.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #
+      #       validates_inclusion_of :state, in: %w(open resolved unresolved)
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it { should ensure_inclusion_of(:state).in_array(%w(open resolved unresolved)) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:state).in_array(%w(open resolved unresolved))
+      #     end
+      #
+      # ##### in_range
+      #
+      # Use `in_range` if your whitelist is a range of values.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #
+      #       validates_inclusion_of :priority, in: 1..5
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it { should ensure_inclusion_of(:state).in_range(1..5) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:state).in_range(1..5)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #
+      #       validates_inclusion_of :severity,
+      #         in: %w(low medium high),
+      #         message: 'Severity must be low, medium, or high'
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it do
+      #         should ensure_inclusion_of(:severity).
+      #           in_array(%w(low medium high)).
+      #           with_message('Severity must be low, medium, or high')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:severity).
+      #         in_array(%w(low medium high)).
+      #         with_message('Severity must be low, medium, or high')
+      #     end
+      #
+      # ##### with_low_message
+      #
+      # Use `with_low_message` if you have a custom validation message for when
+      # a given value is too low.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validate :age_must_be_valid
+      #
+      #       private
+      #
+      #       def age_must_be_valid
+      #         if age < 65
+      #           self.errors.add :age, 'You do not receive any benefits'
+      #         end
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should ensure_inclusion_of(:age).
+      #           in_range(0..65).
+      #           with_low_message('You do not receive any benefits')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:age).
+      #         in_range(0..65).
+      #         with_low_message('You do not receive any benefits')
+      #     end
+      #
+      # ##### with_high_message
+      #
+      # Use `with_high_message` if you have a custom validation message for
+      # when a given value is too high.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #
+      #       validate :age_must_be_valid
+      #
+      #       private
+      #
+      #       def age_must_be_valid
+      #         if age > 21
+      #           self.errors.add :age, "You're too old for this stuff"
+      #         end
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should ensure_inclusion_of(:age).
+      #           in_range(0..21).
+      #           with_high_message("You're too old for this stuff")
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:age).
+      #         in_range(0..21).
+      #         with_high_message("You're too old for this stuff")
+      #     end
+      #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` to assert that the attribute allows nil.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #
+      #       validates_presence_of :state
+      #       validates_inclusion_of :state,
+      #         in: %w(open resolved unresolved),
+      #         allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it do
+      #         should ensure_inclusion_of(:state).
+      #           in_array(%w(open resolved unresolved)).
+      #           allow_nil
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:state).
+      #         in_array(%w(open resolved unresolved)).
+      #         allow_nil
+      #     end
+      #
+      # ##### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows blank.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #
+      #       validates_presence_of :state
+      #       validates_inclusion_of :state,
+      #         in: %w(open resolved unresolved),
+      #         allow_blank: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it do
+      #         should ensure_inclusion_of(:state).
+      #           in_array(%w(open resolved unresolved)).
+      #           allow_blank
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should ensure_inclusion_of(:state).
+      #         in_array(%w(open resolved unresolved)).
+      #         allow_blank
+      #     end
+      #
+      # @return [EnsureInclusionOfMatcher]
+      #
+      def ensure_inclusion_of(attr)
+        EnsureInclusionOfMatcher.new(attr)
+      end
+
+      # @private
+      class EnsureInclusionOfMatcher < ValidationMatcher
+        ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
+        ARBITRARY_OUTSIDE_FIXNUM = 123456789
+        ARBITRARY_OUTSIDE_DECIMAL = 0.123456789
+        BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT
+You are using `ensure_inclusion_of` to assert that a boolean column allows
+boolean values and disallows non-boolean ones. Assuming you are using
+`validates_format_of` in your model, be aware that it is not possible to fully
+test this, and in fact the validation is superfluous, as boolean columns will
+automatically convert non-boolean values to boolean ones. Hence, you should
+consider removing this test and the corresponding validation.
+EOT
+        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT
+You are using `ensure_inclusion_of` to assert that a boolean column allows nil.
+Be aware that it is not possible to fully test this, as anything other than
+true, false or nil will be converted to false. Hence, you should consider
+removing this test and the corresponding validation.
+EOT
+        BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE = <<EOT
+You have specified that your model's #{@attribute} should ensure inclusion of nil.
+However, #{@attribute} is a boolean column which does not allow null values.
+Hence, this test will fail and there is no way to make it pass.
+EOT
+
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
+
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = range.first
+          @maximum = range.max
+          self
+        end
+
+        def allow_blank(allow_blank = true)
+          @options[:allow_blank] = allow_blank
+          self
+        end
+
+        def allow_nil(allow_nil = true)
+          @options[:allow_nil] = allow_nil
+          self
+        end
+
+        def with_message(message)
+          if message
+            @low_message = message
+            @high_message = message
+          end
+          self
+        end
+
+        def with_low_message(message)
+          @low_message = message if message
+          self
+        end
+
+        def with_high_message(message)
+          @high_message = message if message
+          self
+        end
+
+        def description
+          "ensure inclusion of #{@attribute} in #{inspect_message}"
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            @low_message  ||= :inclusion
+            @high_message ||= :inclusion
+
+            disallows_lower_value &&
+              allows_minimum_value &&
+              disallows_higher_value &&
+              allows_maximum_value
+          elsif @array
+            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value? && disallows_value_outside_of_array?
+              true
+            else
+              @failure_message = "#{@array} doesn't match array in validation"
+              false
+            end
+          end
+        end
+
+        private
+
+        def allows_blank_value?
+          if @options.key?(:allow_blank)
+            blank_values = ['', ' ', "\n", "\r", "\t", "\f"]
+            @options[:allow_blank] == blank_values.all? { |value| allows_value_of(value) }
+          else
+            true
+          end
+        end
+
+        def allows_nil_value?
+          if @options.key?(:allow_nil)
+            @options[:allow_nil] == allows_value_of(nil)
+          else
+            true
+          end
+        end
+
+        def inspect_message
+          @range.nil? ? @array.inspect : @range.inspect
+        end
+
+        def allows_all_values_in_array?
+          @array.all? do |value|
+            allows_value_of(value, @low_message)
+          end
+        end
+
+        def disallows_lower_value
+          @minimum == 0 || disallows_value_of(@minimum - 1, @low_message)
+        end
+
+        def disallows_higher_value
+          disallows_value_of(@maximum + 1, @high_message)
+        end
+
+        def allows_minimum_value
+          allows_value_of(@minimum, @low_message)
+        end
+
+        def allows_maximum_value
+          allows_value_of(@maximum, @high_message)
+        end
+
+        def disallows_value_outside_of_array?
+          if attribute_column.type == :boolean
+            case @array
+            when [true, false]
+              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              return true
+            when [nil]
+              if attribute_column.null
+                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                return true
+              else
+                raise NonNullableBooleanError, BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE
+              end
+            end
+          end
+
+          !allows_value_of(*values_outside_of_array)
+        end
+
+        def values_outside_of_array
+          if !(@array & outside_values).empty?
+            raise CouldNotDetermineValueOutsideOfArray
+          else
+            outside_values
+          end
+        end
+
+        def outside_values
+          case attribute_column.type
+          when :boolean
+            boolean_outside_values
+          when :integer, :float
+            [ARBITRARY_OUTSIDE_FIXNUM]
+          when :decimal
+            [ARBITRARY_OUTSIDE_DECIMAL]
+          else
+            [ARBITRARY_OUTSIDE_STRING]
+          end
+        end
+
+        def boolean_outside_values
+          values = []
+
+          values << case @array
+            when [true]  then false
+            when [false] then true
+            else              raise CouldNotDetermineValueOutsideOfArray
+          end
+
+          if attribute_column.null
+            values << nil
+          end
+
+          values
+        end
+
+        def attribute_column
+          @subject.class.columns_hash[@attribute.to_s]
+        end
+      end
+    end
+  end
+end