ultra-fast-box 0.0.1

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

@@ -0,0 +1,664 @@
+require 'bigdecimal'
+require 'date'
+
+module Shoulda
+  module Matchers
+    # @private
+    class ExampleClass; end
+
+    module ActiveModel
+      # The `validate_inclusion_of` matcher tests usage of the
+      # `validates_inclusion_of` validation, asserting that an attribute can
+      # take a allowlist of values and cannot take values outside of this list.
+      #
+      # If your allowlist is an array of values, use `in_array`:
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :state
+      #
+      #       validates_inclusion_of :state,
+      #         in: ['open', 'resolved', 'unresolved']
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:state).
+      #           in_array(['open', 'resolved', 'unresolved'])
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:state).
+      #         in_array(['open', 'resolved', 'unresolved'])
+      #     end
+      #
+      # If your allowlist is a range of values, use `in_range`:
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :priority
+      #
+      #       validates_inclusion_of :priority, in: 1..5
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it { should validate_inclusion_of(:priority).in_range(1..5) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:priority).in_range(1..5)
+      #     end
+      #
+      # #### Caveats
+      #
+      # We discourage using `validate_inclusion_of` with boolean columns. In
+      # fact, there is never a case where a boolean column will be anything but
+      # true, false, or nil, as ActiveRecord will type-cast an incoming value to
+      # 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 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
+      # using `allow_value` instead, like this:
+      #
+      #     it { should allow_value(nil).for(:imported) }
+      #
+      # #### Qualifiers
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :severity
+      #
+      #       validates_inclusion_of :severity,
+      #         in: %w(low medium high),
+      #         on: :create
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:severity).
+      #           in_array(%w(low medium high)).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:severity).
+      #         in_array(%w(low medium high)).
+      #         on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :severity
+      #
+      #       validates_inclusion_of :severity,
+      #         in: %w(low medium high),
+      #         message: 'Severity must be low, medium, or high'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:severity).
+      #           in_array(%w(low medium high)).
+      #           with_message('Severity must be low, medium, or high')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_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
+      #       attr_accessor :age
+      #
+      #       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
+      #     RSpec.describe Person, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:age).
+      #           in_range(0..65).
+      #           with_low_message('You do not receive any benefits')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_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
+      #       attr_accessor :age
+      #
+      #       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
+      #     RSpec.describe Person, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:age).
+      #           in_range(0..21).
+      #           with_high_message("You're too old for this stuff")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_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
+      #       attr_accessor :state
+      #
+      #       validates_presence_of :state
+      #       validates_inclusion_of :state,
+      #         in: ['open', 'resolved', 'unresolved'],
+      #         allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:state).
+      #           in_array(['open', 'resolved', 'unresolved']).
+      #           allow_nil
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:state).
+      #         in_array(['open', 'resolved', 'unresolved']).
+      #         allow_nil
+      #     end
+      #
+      # ##### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows blank.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :state
+      #
+      #       validates_presence_of :state
+      #       validates_inclusion_of :state,
+      #         in: ['open', 'resolved', 'unresolved'],
+      #         allow_blank: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should validate_inclusion_of(:state).
+      #           in_array(['open', 'resolved', 'unresolved']).
+      #           allow_blank
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:state).
+      #         in_array(['open', 'resolved', 'unresolved']).
+      #         allow_blank
+      #     end
+      #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :status, :category
+      #
+      #       validates_inclusion_of :status, :category, in: %w[draft published]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_inclusion_of(:status, :category).in_array(%w[draft published]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:status, :category).in_array(%w[draft published])
+      #     end
+      #
+      # @return [ValidateInclusionOfMatcher]
+      #
+      def validate_inclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateInclusionOfMatcher.new(attr) }
+      end
+
+      # @private
+      class ValidateInclusionOfMatcher < ValidationMatcher
+        BLANK_VALUES = ['', ' ', "\n", "\r", "\t", "\f"].freeze
+        ARBITRARY_OUTSIDE_STRING = Shoulda::Matchers::ExampleClass.name
+        ARBITRARY_OUTSIDE_INTEGER = 123456789
+        ARBITRARY_OUTSIDE_DECIMAL = BigDecimal('0.123456789')
+        ARBITRARY_OUTSIDE_DATE = Date.jd(9999999)
+        ARBITRARY_OUTSIDE_DATETIME = DateTime.jd(9999999)
+        ARBITRARY_OUTSIDE_TIME = Time.at(9999999999)
+
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+          @array = nil
+          @range = nil
+          @minimum = nil
+          @maximum = nil
+          @low_message = :inclusion
+          @high_message = :inclusion
+        end
+
+        def in_array(array)
+          @array = array
+          self
+        end
+
+        def in_range(range)
+          @range = range
+          @minimum = minimum_range_value
+          @maximum = maximum_range_value
+          self
+        end
+
+        def allow_nil
+          @options[:allow_nil] = true
+          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)
+          if message
+            @expects_custom_validation_message = true
+            @low_message = message
+          end
+
+          self
+        end
+
+        def with_high_message(message)
+          if message
+            @high_message = message
+          end
+
+          self
+        end
+
+        def simple_description
+          if @range
+            "validate that :#{@attribute} lies inside the range " +
+              Shoulda::Matchers::Util.inspect_range(@range)
+          else
+            description = "validate that :#{@attribute}"
+
+            description <<
+              if @array.length > 1
+                " is either #{inspected_array}"
+              else
+                " is #{inspected_array}"
+              end
+
+            description
+          end
+        end
+
+        def matches?(subject)
+          super(subject)
+
+          if @range
+            matches_for_range?
+          elsif @array
+            if matches_for_array?
+              true
+            else
+              @failure_message = "#{@array} doesn't match array in validation"
+              false
+            end
+          end
+        end
+
+        def does_not_match?(subject)
+          super(subject)
+
+          if @range
+            does_not_match_for_range?
+          elsif @array
+            if does_not_match_for_array?
+              true
+            else
+              @failure_message = "#{@array} matches array in validation"
+              false
+            end
+          end
+        end
+
+        private
+
+        def boolean_allows_boolean_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            allows boolean values and disallows non-boolean ones. Be aware that it
+            is not possible to fully test this, as boolean columns will automatically
+            convert non-boolean values to boolean ones. Hence, you should consider
+            removing this test.
+          EOT
+        end
+
+        def boolean_allows_nil_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            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.
+          EOT
+        end
+
+        def minimum_range_value
+          @range.begin
+        end
+
+        def maximum_range_value
+          if @range.exclude_end?
+            @range.end ? (@range.end - 1) : nil
+          else
+            @range.end
+          end
+        end
+
+        def matches_for_range?
+          disallows_lower_value &&
+            allows_minimum_value &&
+            allows_maximum_value &&
+            disallows_higher_value
+        end
+
+        def does_not_match_for_range?
+          allows_lower_value ||
+            disallows_minimum_value ||
+            disallows_maximum_value ||
+            allows_higher_value
+        end
+
+        def matches_for_array?
+          allows_all_values_in_array? &&
+            disallows_all_values_outside_of_array? &&
+            allows_nil_value? &&
+            allow_blank_matches?
+        end
+
+        def does_not_match_for_array?
+          disallows_any_values_in_array? ||
+            allows_any_value_outside_of_array? ||
+            disallows_nil_value? ||
+            allow_blank_does_not_match?
+        end
+
+        def allows_lower_value
+          @minimum &&
+            @minimum != 0 &&
+            allows_value_of(@minimum - 1, @low_message)
+        end
+
+        def disallows_lower_value
+          @minimum.nil? ||
+            @minimum == 0 ||
+            disallows_value_of(@minimum - 1, @low_message)
+        end
+
+        def allows_minimum_value
+          @minimum.nil? || allows_value_of(@minimum, @low_message)
+        end
+
+        def disallows_minimum_value
+          @minimum.nil? || disallows_value_of(@minimum, @low_message)
+        end
+
+        def allows_maximum_value
+          @maximum.nil? || allows_value_of(@maximum, @high_message)
+        end
+
+        def disallows_maximum_value
+          @maximum.nil? || disallows_value_of(@maximum, @high_message)
+        end
+
+        def allows_higher_value
+          @maximum.nil? || allows_value_of(@maximum + 1, @high_message)
+        end
+
+        def disallows_higher_value
+          @maximum.nil? || disallows_value_of(@maximum + 1, @high_message)
+        end
+
+        def allows_all_values_in_array?
+          @array.all? do |value|
+            allows_value_of(value, @low_message)
+          end
+        end
+
+        def disallows_any_values_in_array?
+          @array.any? do |value|
+            disallows_value_of(value, @low_message)
+          end
+        end
+
+        def allows_any_value_outside_of_array?
+          if attribute_type == :boolean
+            case @array
+            when [false, true], [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.create(@attribute)
+              end
+            end
+          end
+
+          values_outside_of_array.any? do |value|
+            allows_value_of(value, @low_message)
+          end
+        end
+
+        def disallows_all_values_outside_of_array?
+          if attribute_type == :boolean
+            case @array
+            when [false, true], [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.create(@attribute)
+              end
+            end
+          end
+
+          values_outside_of_array.all? do |value|
+            disallows_value_of(value, @low_message)
+          end
+        end
+
+        def values_outside_of_array
+          if !(@array & outside_values).empty?
+            raise CouldNotDetermineValueOutsideOfArray
+          else
+            outside_values
+          end
+        end
+
+        def outside_values
+          case attribute_type
+          when :boolean
+            boolean_outside_values
+          when :integer
+            [ARBITRARY_OUTSIDE_INTEGER]
+          when :decimal
+            [ARBITRARY_OUTSIDE_DECIMAL]
+          when :date
+            [ARBITRARY_OUTSIDE_DATE]
+          when :datetime
+            [ARBITRARY_OUTSIDE_DATETIME]
+          when :time
+            [ARBITRARY_OUTSIDE_TIME]
+          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_allows_nil?
+            values << nil
+          end
+
+          values
+        end
+
+        def attribute_type
+          if attribute_column
+            column_type_to_attribute_type(attribute_column.type)
+          else
+            value_to_attribute_type(@subject.__send__(@attribute))
+          end
+        end
+
+        def attribute_allows_nil?
+          if attribute_column
+            attribute_column.null
+          else
+            true
+          end
+        end
+
+        def attribute_column
+          if @subject.class.respond_to?(:columns_hash)
+            @subject.class.columns_hash[@attribute.to_s]
+          end
+        end
+
+        def column_type_to_attribute_type(type)
+          case type
+          when :float then :integer
+          when :timestamp then :datetime
+          else type
+          end
+        end
+
+        def value_to_attribute_type(value)
+          case value
+          when true, false then :boolean
+          when BigDecimal then :decimal
+          when Integer then :integer
+          when Date then :date
+          when DateTime then :datetime
+          when Time then :time
+          else :unknown
+          end
+        end
+
+        def allows_nil_value?
+          @options[:allow_nil] != true || allows_value_of(nil)
+        end
+
+        def disallows_nil_value?
+          @options[:allow_nil] && disallows_value_of(nil)
+        end
+
+        def inspected_array
+          Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
+            two_words_connector: ' or ',
+            last_word_connector: ', or ',
+          )
+        end
+      end
+    end
+  end
+end