shoulda-matchers 3.0.1 → 3.1.0

data/lib/shoulda/matchers/active_record/validate_uniqueness_of_matcher.rb

@@ -57,7 +57,7 @@ module Shoulda
       #
       #     Failures:
       #
-      #       1) Post should require case sensitive unique value for title
+      #       1) Post should validate :title to be case-sensitively unique
       #          Failure/Error: it { should validate_uniqueness_of(:title) }
       #          ActiveRecord::StatementInvalid:
       #            SQLite3::ConstraintException: posts.content may not be NULL: INSERT INTO "posts" ("title") VALUES (?)
@@ -133,7 +133,7 @@ module Shoulda
       # unique, but the scoped attributes are not unique either.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :slug, scope: :user_id
+      #       validates_uniqueness_of :slug, scope: :journal_id
       #     end
       #
       #     # RSpec
@@ -167,6 +167,40 @@ module Shoulda
       #       should validate_uniqueness_of(:key).case_insensitive
       #     end
       #
+      # ##### ignoring_case_sensitivity
+      #
+      # By default, `validate_uniqueness_of` will check that the
+      # validation is case sensitive: it asserts that uniquable attributes pass
+      # validation when their values are in a different case than corresponding
+      # attributes in the pre-existing record.
+      #
+      # Use `ignoring_case_sensitivity` to skip this check. This qualifier is
+      # particularly handy if your model has somehow changed the behavior of
+      # attribute you're testing so that it modifies the case of incoming values
+      # as they are set. For instance, perhaps you've overridden the writer
+      # method or added a `before_validation` callback to normalize the
+      # attribute.
+      #
+      #     class User < ActiveRecord::Base
+      #       validates_uniqueness_of :email
+      #
+      #       def email=(value)
+      #         super(value.downcase)
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it do
+      #         should validate_uniqueness_of(:email).ignoring_case_sensitivity
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:email).ignoring_case_sensitivity
+      #     end
+      #
       # ##### allow_nil
       #
       # Use `allow_nil` to assert that the attribute allows nil.
@@ -217,7 +251,17 @@ module Shoulda
 
         def initialize(attribute)
           super(attribute)
-          @options = {}
+          @expected_message = :taken
+          @options = {
+            case_sensitivity_strategy: :sensitive
+          }
+          @existing_record_created = false
+          @failure_reason = nil
+          @failure_reason_when_negated = nil
+          @attribute_setters = {
+            existing_record: [],
+            new_record: []
+          }
         end
 
         def scoped_to(*scopes)
@@ -225,13 +269,13 @@ module Shoulda
           self
         end
 
-        def with_message(message)
-          @expected_message = message
+        def case_insensitive
+          @options[:case_sensitivity_strategy] = :insensitive
           self
         end
 
-        def case_insensitive
-          @options[:case_insensitive] = true
+        def ignoring_case_sensitivity
+          @options[:case_sensitivity_strategy] = :ignore
           self
         end
 
@@ -240,28 +284,40 @@ module Shoulda
           self
         end
 
+        def expects_to_allow_nil?
+          @options[:allow_nil]
+        end
+
         def allow_blank
           @options[:allow_blank] = true
           self
         end
 
-        def description
-          result = "require "
-          result << "case sensitive " unless @options[:case_insensitive]
-          result << "unique value for #{@attribute}"
-          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
-          result
+        def expects_to_allow_blank?
+          @options[:allow_blank]
         end
 
-        def matches?(subject)
-          @original_subject = subject
-          @subject = subject.class.new
-          @expected_message ||= :taken
-          @all_records = @subject.class.all
+        def simple_description
+          description = "validate that :#{@attribute} is"
+          description << description_for_case_sensitive_qualifier
+          description << ' unique'
 
-          scopes_match? &&
-            set_scoped_attributes &&
-            validate_everything_except_duplicate_nils_or_blanks? &&
+          if @options[:scopes].present?
+            description << " within the scope of #{inspected_expected_scopes}"
+          end
+
+          description
+        end
+
+        def matches?(given_record)
+          @given_record = given_record
+          @all_records = model.all
+
+          existing_record_valid? &&
+            validate_attribute_present? &&
+            validate_scopes_present? &&
+            scopes_match? &&
+            validate_two_records_with_same_non_blank_value_cannot_coexist? &&
             validate_case_sensitivity? &&
             validate_after_scope_change? &&
             allows_nil? &&
@@ -270,42 +326,102 @@ module Shoulda
           Uniqueness::TestModels.remove_all
         end
 
-        private
+        protected
 
-        def validation
-          @subject.class._validators[@attribute].detect do |validator|
-            validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
+        def failure_reason
+          @failure_reason || super
+        end
+
+        def failure_reason_when_negated
+          @failure_reason_when_negated || super
+        end
+
+        def build_allow_or_disallow_value_matcher(args)
+          super.tap do |matcher|
+            matcher.failure_message_preface = method(:failure_message_preface)
+            matcher.attribute_changed_value_message =
+              method(:attribute_changed_value_message)
           end
         end
 
-        def scopes_match?
-          expected_scopes = Array.wrap(@options[:scopes])
+        private
 
-          if validation
-            actual_scopes = Array.wrap(validation.options[:scope])
+        def case_sensitivity_strategy
+          @options[:case_sensitivity_strategy]
+        end
+
+        def new_record
+          unless defined?(@new_record)
+            build_new_record
+          end
+
+          @new_record
+        end
+        alias_method :subject, :new_record
+
+        def description_for_case_sensitive_qualifier
+          case case_sensitivity_strategy
+          when :sensitive
+            ' case-sensitively'
+          when :insensitive
+            ' case-insensitively'
           else
-            actual_scopes = []
+            ''
           end
+        end
+
+        def validation
+          model._validators[@attribute].detect do |validator|
+            validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
+          end
+        end
 
+        def scopes_match?
           if expected_scopes == actual_scopes
             true
           else
-            @failure_message = "Expected validation to be scoped to " +
-              "#{expected_scopes}"
+            @failure_reason = 'Expected the validation'
 
-            if actual_scopes.present?
-              @failure_message << ", but it was scoped to #{actual_scopes}."
+            if expected_scopes.empty?
+              @failure_reason << ' not to be scoped to anything'
             else
-              @failure_message << ", but it was not scoped to anything."
+              @failure_reason << " to be scoped to #{inspected_expected_scopes}"
+            end
+
+            if actual_scopes.empty?
+              @failure_reason << ', but it was not scoped to anything.'
+            else
+              @failure_reason << ', but it was scoped to '
+              @failure_reason << "#{inspected_actual_scopes} instead."
             end
 
             false
           end
         end
 
+        def expected_scopes
+          Array.wrap(@options[:scopes])
+        end
+
+        def inspected_expected_scopes
+          expected_scopes.map(&:inspect).to_sentence
+        end
+
+        def actual_scopes
+          if validation
+            Array.wrap(validation.options[:scope])
+          else
+            []
+          end
+        end
+
+        def inspected_actual_scopes
+          actual_scopes.map(&:inspect).to_sentence
+        end
+
         def allows_nil?
-          if @options[:allow_nil]
-            ensure_nil_record_in_database
+          if expects_to_allow_nil?
+            update_existing_record!(nil)
             allows_value_of(nil, @expected_message)
           else
             true
@@ -313,48 +429,69 @@ module Shoulda
         end
 
         def allows_blank?
-          if @options[:allow_blank]
-            ensure_blank_record_in_database
+          if expects_to_allow_blank?
+            update_existing_record!('')
             allows_value_of('', @expected_message)
           else
             true
           end
         end
 
-        def existing_record
-          @existing_record ||= first_instance
-        end
-
-        def first_instance
-          @subject.class.first || create_record_in_database
+        def existing_record_valid?
+          if existing_record.valid?
+            true
+          else
+            @failure_reason =
+              "The record you provided could not be created, " +
+              "as it failed with the following validation errors:\n\n" +
+              format_validation_errors(existing_record.errors)
+            false
+          end
         end
 
-        def ensure_nil_record_in_database
-          unless existing_record_is_nil?
-            create_record_in_database(nil_value: true)
+        def existing_record
+          unless defined?(@existing_record)
+            find_or_create_existing_record
           end
+
+          @existing_record
         end
 
-        def ensure_blank_record_in_database
-          unless existing_record_is_blank?
-            create_record_in_database(blank_value: true)
+        def find_or_create_existing_record
+          @existing_record = find_existing_record
+
+          unless @existing_record
+            @existing_record = create_existing_record
+            @existing_record_created = true
           end
         end
 
-        def existing_record_is_nil?
-          @existing_record.present? && existing_value.nil?
+        def find_existing_record
+          record = model.first
+
+          if record.present?
+            record
+          else
+            nil
+          end
         end
 
-        def existing_record_is_blank?
-          @existing_record.present? && existing_value.strip == ''
+        def create_existing_record
+          @given_record.tap do |existing_record|
+            ensure_secure_password_set(existing_record)
+            existing_record.save
+          end
         end
 
-        def create_record_in_database(options = {})
-          @original_subject.tap do |instance|
-            instance.__send__("#{@attribute}=", value_for_new_record(options))
-            ensure_secure_password_set(instance)
-            instance.save(validate: false)
-            @created_record = instance
+        def update_existing_record!(value)
+          if existing_value_read != value
+            set_attribute_on!(
+              :existing_record,
+              existing_record,
+              @attribute,
+              value
+            )
+            existing_record.save!
           end
         end
 
@@ -365,70 +502,117 @@ module Shoulda
           end
         end
 
-        def value_for_new_record(options = {})
-          case
-            when options[:nil_value] then nil
-            when options[:blank_value] then ''
-            else 'a'
+        def arbitrary_non_blank_value
+          limit = column_limit_for(@attribute)
+          non_blank_value = 'an arbitrary value'
+
+          if limit && limit < non_blank_value.length
+            'x' * limit
+          else
+            non_blank_value
           end
         end
 
         def has_secure_password?
-          @subject.class.ancestors.map(&:to_s).include?('ActiveModel::SecurePassword::InstanceMethodsOnActivation')
+          model.ancestors.map(&:to_s).include?(
+            'ActiveModel::SecurePassword::InstanceMethodsOnActivation'
+          )
         end
 
-        def set_scoped_attributes
-          if @options[:scopes].present?
-            @options[:scopes].all? do |scope|
-              setter = :"#{scope}="
-              if @subject.respond_to?(setter)
-                @subject.__send__(setter, existing_record.__send__(scope))
-                true
-              else
-                @failure_message = "#{class_name} doesn't seem to have a #{scope} attribute."
-                false
-              end
-            end
+        def build_new_record
+          @new_record = existing_record.dup
+
+          attribute_names_under_test.each do |attribute_name|
+            set_attribute_on_new_record!(
+              attribute_name,
+              existing_record.public_send(attribute_name)
+            )
+          end
+
+          @new_record
+        end
+
+        def validate_attribute_present?
+          if model.method_defined?("#{attribute}=")
+            true
           else
+            @failure_reason =
+              ":#{attribute} does not seem to be an attribute on #{model.name}."
+            false
+          end
+        end
+
+        def validate_scopes_present?
+          if all_scopes_present_on_model?
             true
+          else
+            reason = ''
+
+            reason << inspected_scopes_missing_on_model.to_sentence
+
+            if inspected_scopes_missing_on_model.many?
+              reason << " do not seem to be attributes"
+            else
+              reason << " does not seem to be an attribute"
+            end
+
+            reason << " on #{model.name}."
+
+            @failure_reason = reason
+
+            false
           end
         end
 
-        def validate_everything_except_duplicate_nils_or_blanks?
-          if (@options[:allow_nil] && existing_value.nil?) ||
-             (@options[:allow_blank] && existing_value.blank?)
-            create_record_with_value
+        def all_scopes_present_on_model?
+          scopes_missing_on_model.none?
+        end
+
+        def scopes_missing_on_model
+          @_missing_scopes ||= expected_scopes.select do |scope|
+            !model.method_defined?("#{scope}=")
           end
+        end
 
-          disallows_value_of(existing_value, @expected_message)
+        def inspected_scopes_missing_on_model
+          scopes_missing_on_model.map(&:inspect)
         end
 
-        def validate_case_sensitivity?
-          value = existing_value
+        def validate_two_records_with_same_non_blank_value_cannot_coexist?
+          if existing_value_read.blank?
+            update_existing_record!(arbitrary_non_blank_value)
+          end
+
+          disallows_value_of(existing_value_read, @expected_message)
+        end
 
-          if value.respond_to?(:swapcase)
+        def validate_case_sensitivity?
+          if should_validate_case_sensitivity?
+            value = existing_value_read
             swapcased_value = value.swapcase
 
-            if @options[:case_insensitive]
-              disallows_value_of(swapcased_value, @expected_message)
-            else
+            if case_sensitivity_strategy == :sensitive
               if value == swapcased_value
                 raise NonCaseSwappableValueError.create(
-                  model: @subject.class,
+                  model: model,
                   attribute: @attribute,
                   value: value
                 )
               end
 
               allows_value_of(swapcased_value, @expected_message)
+            else
+              disallows_value_of(swapcased_value, @expected_message)
             end
           else
             true
           end
         end
 
-        def create_record_with_value
-          @existing_record = create_record_in_database
+        def should_validate_case_sensitivity?
+          case_sensitivity_strategy != :ignore &&
+            existing_value_read.respond_to?(:swapcase) &&
+            !existing_value_read.empty?
         end
 
         def model_class?(model_name)
@@ -438,10 +622,10 @@ module Shoulda
         end
 
         def validate_after_scope_change?
-          if @options[:scopes].blank? || all_scopes_are_booleans?
+          if expected_scopes.empty? || all_scopes_are_booleans?
             true
           else
-            @options[:scopes].all? do |scope|
+            expected_scopes.all? do |scope|
               previous_value = @all_records.map(&scope).compact.max
 
               next_value =
@@ -451,16 +635,12 @@ module Shoulda
                   next_value_for(scope, previous_value)
                 end
 
-              @subject.__send__("#{scope}=", next_value)
-
-              if allows_value_of(existing_value, @expected_message)
-                @subject.__send__("#{scope}=", previous_value)
+              set_attribute_on_new_record!(scope, next_value)
 
-                @failure_message_when_negated <<
-                  " (with different value of #{scope})"
+              if allows_value_of(existing_value_read, @expected_message)
+                set_attribute_on_new_record!(scope, previous_value)
                 true
               else
-                @failure_message << " (with different value of #{scope})"
                 false
               end
             end
@@ -478,20 +658,7 @@ module Shoulda
         end
 
         def dummy_scalar_value_for(column)
-          case column.type
-          when :integer
-            0
-          when :date
-            Date.today
-          when :datetime
-            DateTime.now
-          when :uuid
-            SecureRandom.uuid
-          when :boolean
-            true
-          else
-            'dummy value'
-          end
+          Shoulda::Matchers::Util.dummy_value_for(column.type)
         end
 
         def next_value_for(scope, previous_value)
@@ -534,8 +701,8 @@ module Shoulda
         end
 
         def defined_as_enum?(scope)
-          @subject.class.respond_to?(:defined_enums) &&
-            @subject.defined_enums[scope.to_s]
+          model.respond_to?(:defined_enums) &&
+            new_record.defined_enums[scope.to_s]
         end
 
         def polymorphic_type_attribute?(scope, previous_value)
@@ -543,21 +710,180 @@ module Shoulda
         end
 
         def available_enum_values_for(scope, previous_value)
-          @subject.defined_enums[scope.to_s].reject do |key, _|
+          new_record.defined_enums[scope.to_s].reject do |key, _|
             key == previous_value
           end
         end
 
-        def existing_value
-          existing_record.__send__(@attribute)
+        def set_attribute_on!(record_type, record, attribute_name, value)
+          attribute_setter = build_attribute_setter(
+            record,
+            attribute_name,
+            value
+          )
+          attribute_setter.set!
+
+          @attribute_setters[record_type] << attribute_setter
+        end
+
+        def set_attribute_on_existing_record!(attribute_name, value)
+          set_attribute_on!(
+            :existing_record,
+            existing_record,
+            attribute_name,
+            value
+          )
+        end
+
+        def set_attribute_on_new_record!(attribute_name, value)
+          set_attribute_on!(
+            :new_record,
+            new_record,
+            attribute_name,
+            value
+          )
+        end
+
+        def attribute_setter_for_existing_record
+          @attribute_setters[:existing_record].last
+        end
+
+        def attribute_names_under_test
+          [@attribute] + expected_scopes
         end
 
-        def class_name
-          @subject.class.name
+        def build_attribute_setter(record, attribute_name, value)
+          Shoulda::Matchers::ActiveModel::AllowValueMatcher::AttributeSetter.new(
+            matcher_name: :validate_uniqueness_of,
+            object: record,
+            attribute_name: attribute_name,
+            value: value,
+            ignore_interference_by_writer: ignore_interference_by_writer
+          )
+        end
+
+        def existing_value_read
+          existing_record.public_send(@attribute)
+        end
+
+        def existing_value_written
+          if attribute_setter_for_existing_record
+            attribute_setter_for_existing_record.value_written
+          else
+            existing_value_read
+          end
         end
 
         def column_for(scope)
-          @subject.class.columns_hash[scope.to_s]
+          model.columns_hash[scope.to_s]
+        end
+
+        def column_limit_for(attribute)
+          column_for(attribute).try(:limit)
+        end
+
+        def model
+          @given_record.class
+        end
+
+        def failure_message_preface
+          prefix = ''
+
+          if @existing_record_created
+            prefix << "After taking the given #{model.name}"
+
+            if attribute_setter_for_existing_record
+              prefix << ', setting its '
+              prefix << description_for_attribute_setter(
+                attribute_setter_for_existing_record
+              )
+            else
+              prefix << ", whose :#{attribute} is "
+              prefix << "‹#{existing_value_read.inspect}›"
+            end
+
+            prefix << ", and saving it as the existing record, then"
+          else
+            if attribute_setter_for_existing_record
+              prefix << "Given an existing #{model.name},"
+              prefix << ' after setting its '
+              prefix << description_for_attribute_setter(
+                attribute_setter_for_existing_record
+              )
+              prefix << ', then'
+            else
+              prefix << "Given an existing #{model.name} whose :#{attribute}"
+              prefix << ' is '
+              prefix << Shoulda::Matchers::Util.inspect_value(
+                existing_value_read
+              )
+              prefix << ', after'
+            end
+          end
+
+          prefix << " making a new #{model.name} and setting its "
+
+          prefix << description_for_attribute_setter(
+            last_attribute_setter_used_on_new_record,
+            same_as_existing: existing_and_new_values_are_same?
+          )
+
+          prefix << ", the matcher expected the new #{model.name} to be"
+
+          prefix
+        end
+
+        def attribute_changed_value_message
+          <<-MESSAGE.strip
+As indicated in the message above,
+:#{last_attribute_setter_used_on_new_record.attribute_name} seems to be
+changing certain values as they are set, and this could have something
+to do with why this test is failing. If you or something else has
+overridden the writer method for this attribute to normalize values by
+changing their case in any way (for instance, ensuring that the
+attribute is always downcased), then try adding
+`ignoring_case_sensitivity` onto the end of the uniqueness matcher.
+Otherwise, you may need to write the test yourself, or do something
+different altogether.
+          MESSAGE
+        end
+
+        def description_for_attribute_setter(attribute_setter, same_as_existing: nil)
+          description = ":#{attribute_setter.attribute_name} to "
+
+          if same_as_existing == false
+            description << 'a different value, '
+          end
+
+          description << Shoulda::Matchers::Util.inspect_value(
+            attribute_setter.value_written
+          )
+
+          if attribute_setter.attribute_changed_value?
+            description << ' (read back as '
+            description << Shoulda::Matchers::Util.inspect_value(
+              attribute_setter.value_read
+            )
+            description << ')'
+          end
+
+          if same_as_existing == true
+            description << ' as well'
+          end
+
+          description
+        end
+
+        def existing_and_new_values_are_same?
+          last_value_set_on_new_record == existing_value_written
+        end
+
+        def last_attribute_setter_used_on_new_record
+          last_submatcher_run.last_attribute_setter_used
+        end
+
+        def last_value_set_on_new_record
+          last_submatcher_run.last_value_set
         end
 
         # @private