Add ignoring case sensitivity to uniqueness validation matcher

lib/shoulda/matchers/active_record/validate_uniqueness_of_matcher.rb

@@ -167,6 +167,35 @@ module ActiveRecord
       #       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. Use this if the
+      # model modifies the case of the attribute before setting it on the model
+      # e.g. with a custom setter  or as part of validation.
+      #
+      #     class Post < ActiveRecord::Base
+      #       validates_uniqueness_of :key
+      #
+      #       def key=(value)
+      #         super value.downcase
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should validate_uniqueness_of(:key).ignoring_case_sensitivity }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:key).ignoring_case_sensitivity
+      #     end
+      #
       # ##### allow_nil
       #
       # Use `allow_nil` to assert that the attribute allows nil.
@@ -218,6 +247,7 @@ class ValidateUniquenessOfMatcher < ActiveModel::ValidationMatcher
         def initialize(attribute)
           super(attribute)
           @options = {}
+          @options[:case] = :sensitive
         end
 
         def scoped_to(*scopes)
@@ -231,7 +261,12 @@ def with_message(message)
         end
 
         def case_insensitive
-          @options[:case_insensitive] = true
+          @options[:case] = :insensitive
+          self
+        end
+
+        def ignoring_case_sensitivity
+          @options[:case] = :ignore
           self
         end
 
@@ -247,7 +282,7 @@ def allow_blank
 
         def description
           result = "require "
-          result << "case sensitive " unless @options[:case_insensitive]
+          result << case_description
           result << "unique value for #{@attribute}"
           result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
           result
@@ -272,6 +307,17 @@ def matches?(subject)
 
         private
 
+        def case_description
+          case @options[:case]
+          when :sensitive
+            'case sensitive '
+          when :insensitive
+            'case insensitive '
+          else
+            ''
+          end
+        end
+
         def validation
           @subject.class._validators[@attribute].detect do |validator|
             validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
@@ -409,9 +455,10 @@ def validate_case_sensitivity?
           if value.respond_to?(:swapcase)
             swapcased_value = value.swapcase
 
-            if @options[:case_insensitive]
+            case @options[:case]
+            when :insensitive
               disallows_value_of(swapcased_value, @expected_message)
-            else
+            when :sensitive
               if value == swapcased_value
                 raise NonCaseSwappableValueError.create(
                   model: @subject.class,
@@ -421,6 +468,8 @@ def validate_case_sensitivity?
               end
 
               allows_value_of(swapcased_value, @expected_message)
+            else
+              true
             end
           else
             true

spec/unit/shoulda/matchers/active_record/validate_uniqueness_of_matcher_spec.rb

@@ -726,6 +726,51 @@
     end
   end
 
+  context 'when the writer method for the attribute changes incoming values' do
+    context 'and ignoring_case_sensitivity is not specified' do
+      it 'raises a CouldNotSetAttributeError' do
+        model = define_model_validating_uniqueness(
+          attribute_name: :name,
+          validation_options: { case_sensitive: false },
+        )
+
+        model.class_eval do
+          def name=(name)
+            super(name.upcase)
+          end
+        end
+
+        assertion = lambda do
+          expect(model.new).
+            to validate_uniqueness_of(:name).
+            case_insensitive
+        end
+
+        expect(&assertion).to raise_error(
+          Shoulda::Matchers::ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
+        )
+      end
+    end
+
+    context 'and ignoring_case_sensitivity is specified' do
+      it 'accepts (and not raise an error)' do
+        model = define_model_validating_uniqueness(
+          attribute_name: :name,
+        )
+
+        model.class_eval do
+          def name=(name)
+            super(name.upcase)
+          end
+        end
+
+        expect(model.new).
+          to validate_uniqueness_of(:name).
+          ignoring_case_sensitivity
+      end
+    end
+  end
+
   let(:model_attributes) { {} }
 
   def default_attribute
@@ -846,6 +891,7 @@ def determine_scope_attribute_names_from(scope_attributes)
   end
 
   def define_model_validating_uniqueness(options = {}, &block)
+    attribute_name = options.fetch(:attribute_name) { self.attribute_name }
     attribute_type = options.fetch(:attribute_type, :string)
     attribute_options = options.fetch(:attribute_options, {})
     attribute = {