shoulda-matchers 3.0.1 → 3.1.0

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

@@ -66,88 +66,193 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
     end
 
     context 'when too narrow of a scope is specified' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
           scopes: [
             build_attribute(name: :scope1),
-            { name: :scope2 }
+            build_attribute(name: :scope2)
           ],
+          additional_attributes: [:other]
         )
-        expect(record).
-          not_to validate_uniqueness.
-          scoped_to(:scope1, :scope2, :other)
+
+        assertion = lambda do
+          expect(record).
+            to validate_uniqueness.
+            scoped_to(:scope1, :scope2, :other)
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :scope1, :scope2, and :other.
+  Expected the validation to be scoped to :scope1, :scope2, and :other,
+  but it was scoped to :scope1 and :scope2 instead.
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'when too broad of a scope is specified' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
           scopes: [
             build_attribute(name: :scope1),
-            { name: :scope2 }
+            build_attribute(name: :scope2)
           ],
         )
-        expect(record).
-          not_to validate_uniqueness.
-          scoped_to(:scope1)
+
+        assertion = lambda do
+          expect(record).
+            to validate_uniqueness.
+            scoped_to(:scope1)
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :scope1.
+  Expected the validation to be scoped to :scope1, but it was scoped to
+  :scope1 and :scope2 instead.
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'when a different scope is specified' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
-          scopes: [ build_attribute(name: :scope) ],
-          additional_attributes: [:other]
+          scopes: [ build_attribute(name: :other) ],
+          additional_attributes: [:scope]
         )
-        expect(record).
-          not_to validate_uniqueness.
-          scoped_to(:other)
+        assertion = lambda do
+          expect(record).
+            to validate_uniqueness.
+            scoped_to(:scope)
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :scope.
+  Expected the validation to be scoped to :scope, but it was scoped to
+  :other instead.
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'when no scope is specified' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
           scopes: [ build_attribute(name: :scope) ]
         )
-        expect(record).not_to validate_uniqueness
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique.
+  Expected the validation not to be scoped to anything, but it was
+  scoped to :scope instead.
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it 'rejects if the scope is unset beforehand' do
-        record = build_record_validating_uniqueness(
-          scopes: [ build_attribute(name: :scope, value: nil) ]
-        )
-        expect(record).not_to validate_uniqueness
+      context 'if the scope attribute is unset in the record given to the matcher' do
+        it 'rejects with an appropriate failure message' do
+          record = build_record_validating_uniqueness(
+            scopes: [ build_attribute(name: :scope, value: nil) ]
+          )
+
+          assertion = lambda do
+            expect(record).to validate_uniqueness
+          end
+
+          message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique.
+  Expected the validation not to be scoped to anything, but it was
+  scoped to :scope instead.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
       end
     end
 
     context 'when a non-existent attribute is specified as a scope' do
-      it 'rejects' do
-        record = build_record_validating_uniqueness(
-          scopes: [ build_attribute(name: :scope) ]
-        )
-        expect(record).not_to validate_uniqueness.scoped_to(:non_existent)
+      context 'when there is more than one scope' do
+        it 'rejects with an appropriate failure message (and does not raise an error)' do
+          record = build_record_validating_uniqueness(
+            scopes: [ build_attribute(name: :scope) ]
+          )
+
+          assertion = lambda do
+            expect(record).to validate_uniqueness.scoped_to(:non_existent)
+          end
+
+          message = <<-MESSAGE.strip
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :non_existent.
+  :non_existent does not seem to be an attribute on Example.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when there is more than one scope' do
+        it 'rejects with an appropriate failure message (and does not raise an error)' do
+          record = build_record_validating_uniqueness(
+            scopes: [ build_attribute(name: :scope) ]
+          )
+
+          assertion = lambda do
+            expect(record).to validate_uniqueness.scoped_to(
+              :non_existent1,
+              :non_existent2
+            )
+          end
+
+          message = <<-MESSAGE.strip
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :non_existent1 and :non_existent2.
+  :non_existent1 and :non_existent2 do not seem to be attributes on
+  Example.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
       end
     end
 
     define_method(:build_attribute) do |attribute_options|
-      attribute_options.merge(
+      attribute_options.deep_merge(
         column_type: column_type,
         value_type: value_type,
-        array: array
+        options: { array: array }
       )
     end
   end
 
   context 'when the model does not have a uniqueness validation' do
-    it 'rejects' do
-      model = define_model(:example, attribute_name => :string) do |m|
-        m.attr_accessible attribute_name
+    it 'rejects with an appropriate failure message' do
+      model = define_model_without_validation
+      model.create!(attribute_name => 'value')
+
+      assertion = lambda do
+        expect(model.new).to validate_uniqueness_of(attribute_name)
       end
 
-      model.create!(attr: 'value')
+      message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique.
+  Given an existing Example whose :attr is ‹"value"›, after making a new
+  Example and setting its :attr to ‹"value"› as well, the matcher
+  expected the new Example to be invalid, but it was valid instead.
+      MESSAGE
 
-      expect(model.new).not_to validate_uniqueness_of(attribute_name)
+      expect(&assertion).to fail_with_message(message)
     end
   end
 
@@ -179,13 +284,25 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
       end
 
       context 'when the validation has no scope and a scope is specified' do
-        it 'rejects' do
+        it 'rejects with an appropriate failure message' do
           model = define_model_validating_uniqueness(
             additional_attributes: [:other]
           )
           create_record_from(model)
           record = build_record_from(model)
-          expect(record).not_to validate_uniqueness.scoped_to(:other)
+
+          assertion = lambda do
+            expect(record).to validate_uniqueness.scoped_to(:other)
+          end
+
+          message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :other.
+  Expected the validation to be scoped to :other, but it was not scoped
+  to anything.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
         end
       end
     end
@@ -219,23 +336,60 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
     context 'and the validation has a custom message' do
       context 'when no message is specified' do
-        it 'rejects' do
+        it 'rejects with an appropriate failure message' do
           record = build_record_validating_uniqueness(
+            attribute_value: 'some value',
             validation_options: { message: 'bad value' }
           )
-          expect(record).not_to validate_uniqueness
+
+          assertion = lambda do
+            expect(record).to validate_uniqueness
+          end
+
+          message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique.
+  After taking the given Example, whose :attr is ‹"some value"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to ‹"some value"› as well, the matcher expected the
+  new Example to be invalid and to produce the validation error "has
+  already been taken" on :attr. The record was indeed invalid, but it
+  produced these validation errors instead:
+
+  * attr: ["bad value"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
         end
       end
 
       context 'given a string' do
         context 'when the given and actual messages do not match' do
-          it 'rejects' do
+          it 'rejects with an appropriate failure message' do
             record = build_record_validating_uniqueness(
-              validation_options: { message: 'bad value' }
+              attribute_value: 'some value',
+              validation_options: { message: 'something else entirely' }
             )
-            expect(record).
-              not_to validate_uniqueness.
-              with_message('something else entirely')
+
+            assertion = lambda do
+              expect(record).
+                to validate_uniqueness.
+                with_message('some message')
+            end
+
+            message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+producing a custom validation error on failure.
+  After taking the given Example, whose :attr is ‹"some value"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to ‹"some value"› as well, the matcher expected the
+  new Example to be invalid and to produce the validation error "some
+  message" on :attr. The record was indeed invalid, but it produced
+  these validation errors instead:
+
+  * attr: ["something else entirely"]
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
           end
         end
 
@@ -253,13 +407,32 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
       context 'given a regex' do
         context 'when the given and actual messages do not match' do
-          it 'rejects' do
+          it 'rejects with an appropriate failure message' do
             record = build_record_validating_uniqueness(
-              validation_options: { message: 'Bad value' }
+              attribute_value: 'some value',
+              validation_options: { message: 'something else entirely' }
             )
-            expect(record).
-              not_to validate_uniqueness.
-              with_message(/something else entirely/)
+
+            assertion = lambda do
+              expect(record).
+                to validate_uniqueness.
+                with_message(/some message/)
+            end
+
+            message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+producing a custom validation error on failure.
+  After taking the given Example, whose :attr is ‹"some value"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to ‹"some value"› as well, the matcher expected the
+  new Example to be invalid and to produce a validation error matching
+  ‹/some message/› on :attr. The record was indeed invalid, but it
+  produced these validation errors instead:
+
+  * attr: ["something else entirely"]
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
           end
         end
 
@@ -275,6 +448,36 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
         end
       end
     end
+
+    it_supports(
+      'ignoring_interference_by_writer',
+      tests: {
+        reject_if_qualified_but_changing_value_interferes: {
+          model_name: 'Example',
+          attribute_name: :attr,
+          default_value: 'some value',
+          changing_values_with: :next_value,
+          expected_message: <<-MESSAGE.strip
+Example did not properly validate that :attr is case-sensitively unique.
+  After taking the given Example, whose :attr is ‹"some valuf"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to ‹"some valuf"› (read back as ‹"some valug"›) as
+  well, the matcher expected the new Example to be invalid, but it was
+  valid instead.
+
+  As indicated in the message above, :attr 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
 
   context 'when the model has a scoped uniqueness validation' do
@@ -334,27 +537,49 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
           end
 
           context 'when too narrow of a scope is specified' do
-            it 'rejects' do
+            it 'rejects with an appropriate failure message' do
               record = build_record_validating_scoped_uniqueness_with_enum(
                 enum_scope: :scope1,
                 additional_scopes: [:scope2],
                 additional_attributes: [:other]
               )
-              expect(record).
-                not_to validate_uniqueness.
-                scoped_to(:scope1, :scope2, :other)
+
+              assertion = lambda do
+                expect(record).
+                  to validate_uniqueness.
+                  scoped_to(:scope1, :scope2, :other)
+              end
+
+              message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :scope1, :scope2, and :other.
+  Expected the validation to be scoped to :scope1, :scope2, and :other,
+  but it was scoped to :scope1 and :scope2 instead.
+              MESSAGE
+
+              expect(&assertion).to fail_with_message(message)
             end
           end
 
           context 'when too broad of a scope is specified' do
-            it 'rejects' do
+            it 'rejects with an appropriate failure message' do
               record = build_record_validating_scoped_uniqueness_with_enum(
                 enum_scope: :scope1,
                 additional_scopes: [:scope2]
               )
-              expect(record).
-                not_to validate_uniqueness.
-                scoped_to(:scope1)
+
+              assertion = lambda do
+                expect(record).to validate_uniqueness.scoped_to(:scope1)
+              end
+
+              message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique
+within the scope of :scope1.
+  Expected the validation to be scoped to :scope1, but it was scoped to
+  :scope1 and :scope2 instead.
+              MESSAGE
+
+              expect(&assertion).to fail_with_message(message)
             end
           end
         end
@@ -467,26 +692,55 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
     end
 
     context 'when the matcher is qualified with case_insensitive' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
           attribute_type: :string,
+          attribute_value: 'some value',
           validation_options: { case_sensitive: true }
         )
 
-        expect(record).not_to validate_uniqueness.case_insensitive
+        assertion = lambda do
+          expect(record).to validate_uniqueness.case_insensitive
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-insensitively
+unique.
+  After taking the given Example, whose :attr is ‹"some value"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to a different value, ‹"SOME VALUE"›, the matcher
+  expected the new Example to be invalid, but it was valid instead.
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
   end
 
   context 'when the model has a case-insensitive validation' do
     context 'when case_insensitive is not specified' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         record = build_record_validating_uniqueness(
           attribute_type: :string,
           validation_options: { case_sensitive: false }
         )
 
-        expect(record).not_to validate_uniqueness
+        assertion = lambda do
+          expect(record).to validate_uniqueness
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique.
+  After taking the given Example, setting its :attr to ‹"an arbitrary
+  value"›, and saving it as the existing record, then making a new
+  Example and setting its :attr to a different value, ‹"AN ARBITRARY
+  VALUE"›, the matcher expected the new Example to be valid, but it was
+  invalid instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
@@ -499,6 +753,44 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
         expect(record).to validate_uniqueness.case_insensitive
       end
+
+      it_supports(
+        'ignoring_interference_by_writer',
+        tests: {
+          reject_if_qualified_but_changing_value_interferes: {
+            model_name: 'Example',
+            attribute_name: :attr,
+            default_value: 'some value',
+            changing_values_with: :next_value,
+            expected_message: <<-MESSAGE.strip
+Example did not properly validate that :attr is case-insensitively
+unique.
+  After taking the given Example, whose :attr is ‹"some valuf"›, and
+  saving it as the existing record, then making a new Example and
+  setting its :attr to ‹"some valuf"› (read back as ‹"some valug"›) as
+  well, the matcher expected the new Example to be invalid, but it was
+  valid instead.
+
+  As indicated in the message above, :attr 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
+          }
+        }
+      )
+
+      def validation_matcher_scenario_args
+        super.deep_merge(validation_options: { case_sensitive: false })
+      end
+
+      def configure_validation_matcher(matcher)
+        super(matcher).case_insensitive
+      end
     end
   end
 
@@ -543,18 +835,50 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
   context 'when the validation is not declared with allow_nil' do
     context 'given a new record whose attribute is nil' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness
         record = build_record_from(model, attribute_name => nil)
-        expect(record).not_to validate_uniqueness.allow_nil
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_nil
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not nil.
+  After taking the given Example, setting its :attr to ‹nil›, and saving
+  it as the existing record, then making a new Example and setting its
+  :attr to ‹nil› as well, the matcher expected the new Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'given an existing record whose attribute is nil' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness
         record = create_record_from(model, attribute_name => nil)
-        expect(record).not_to validate_uniqueness.allow_nil
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_nil
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not nil.
+  Given an existing Example, after setting its :attr to ‹nil›, then
+  making a new Example and setting its :attr to ‹nil› as well, the
+  matcher expected the new Example to be valid, but it was invalid
+  instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
   end
@@ -640,38 +964,102 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
   context 'when the validation is not declared with allow_blank' do
     context 'given a new record whose attribute is nil' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness
         record = build_record_from(model, attribute_name => nil)
-        expect(record).not_to validate_uniqueness.allow_blank
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_blank
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not blank.
+  After taking the given Example, setting its :attr to ‹""›, and saving
+  it as the existing record, then making a new Example and setting its
+  :attr to ‹""› as well, the matcher expected the new Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'given an existing record whose attribute is nil' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness
         record = create_record_from(model, attribute_name => nil)
-        expect(record).not_to validate_uniqueness.allow_blank
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_blank
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not blank.
+  Given an existing Example, after setting its :attr to ‹""›, then
+  making a new Example and setting its :attr to ‹""› as well, the
+  matcher expected the new Example to be valid, but it was invalid
+  instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'given a new record whose attribute is empty' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness(
           attribute_type: :string
         )
         record = build_record_from(model, attribute_name => '')
-        expect(record).not_to validate_uniqueness.allow_blank
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_blank
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not blank.
+  After taking the given Example, setting its :attr to ‹""›, and saving
+  it as the existing record, then making a new Example and setting its
+  :attr to ‹""› as well, the matcher expected the new Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
     context 'given an existing record whose attribute is empty' do
-      it 'rejects' do
+      it 'rejects with an appropriate failure message' do
         model = define_model_validating_uniqueness(
           attribute_type: :string
         )
         record = create_record_from(model, attribute_name => '')
-        expect(record).not_to validate_uniqueness.allow_blank
+
+        assertion = lambda do
+          expect(record).to validate_uniqueness.allow_blank
+        end
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is case-sensitively unique,
+but only if it is not blank.
+  Given an existing Example, after setting its :attr to ‹""›, then
+  making a new Example and setting its :attr to ‹""› as well, the
+  matcher expected the new Example to be valid, but it was invalid
+  instead, producing these validation errors:
+
+  * attr: ["has already been taken"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
   end
@@ -726,26 +1114,129 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
     end
   end
 
+  context 'when the model does not have the attribute being tested' do
+    it 'fails with an appropriate failure message' do
+      model = define_model(:example)
+
+      assertion = lambda do
+        expect(model.new).to validate_uniqueness_of(:attr)
+      end
+
+      message = <<-MESSAGE.strip
+Example did not properly validate that :attr is case-sensitively unique.
+  :attr does not seem to be an attribute on Example.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
+  end
+
+  context 'when the writer method for the attribute changes the case of incoming values' do
+    context 'when the validation is case-sensitive' do
+      context 'and the matcher is ensuring that the validation is case-sensitive' do
+        it 'rejects with an appropriate failure message' do
+          model = define_model_validating_uniqueness(
+            attribute_name: :name
+          )
+
+          model.class_eval do
+            def name=(name)
+              super(name.upcase)
+            end
+          end
+
+          assertion = lambda do
+            expect(model.new).to validate_uniqueness_of(:name)
+          end
+
+          message = <<-MESSAGE.strip
+Example did not properly validate that :name is case-sensitively unique.
+  After taking the given Example, setting its :name to ‹"an arbitrary
+  value"› (read back as ‹"AN ARBITRARY VALUE"›), and saving it as the
+  existing record, then making a new Example and setting its :name to
+  ‹"an arbitrary value"› (read back as ‹"AN ARBITRARY VALUE"›) as well,
+  the matcher expected the new Example to be valid, but it was invalid
+  instead, producing these validation errors:
+
+  * name: ["has already been taken"]
+
+  As indicated in the message above, :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
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'and the matcher is ignoring case sensitivity' 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
+
+    context 'when the validation is case-insensitive' do
+      context 'and the matcher is ensuring that the validation is case-insensitive' do
+        it 'accepts (and does not raise an error)' do
+          model = define_model_validating_uniqueness(
+            attribute_name: :name,
+            validation_options: { case_sensitive: false },
+          )
+
+          model.class_eval do
+            def name=(name)
+              super(name.downcase)
+            end
+          end
+
+          expect(model.new).
+            to validate_uniqueness_of(:name).
+            case_insensitive
+        end
+      end
+    end
+  end
+
   let(:model_attributes) { {} }
 
   def default_attribute
     {
       value_type: :string,
       column_type: :string,
-      array: false
+      options: { array: false, null: true }
     }
   end
 
   def normalize_attribute(attribute)
     if attribute.is_a?(Hash)
-      if attribute.key?(:type)
-        attribute[:value_type] = attribute[:type]
-        attribute[:column_type] = attribute[:type]
+      attribute_copy = attribute.dup
+
+      if attribute_copy.key?(:type)
+        attribute_copy[:value_type] = attribute_copy[:type]
+        attribute_copy[:column_type] = attribute_copy[:type]
       end
 
-      default_attribute.merge(attribute)
+      default_attribute.deep_merge(attribute_copy)
     else
-      default_attribute.merge(name: attribute)
+      default_attribute.deep_merge(name: attribute)
     end
   end
 
@@ -757,15 +1248,10 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
 
   def column_options_from(attributes)
     attributes.inject({}) do |options, attribute|
-      options_for_attribute = options[attribute[:name]] = {
+      options[attribute[:name]] = {
         type: attribute[:column_type],
         options: attribute.fetch(:options, {})
       }
-
-      if attribute[:array]
-        options_for_attribute[:options][:array] = attribute[:array]
-      end
-
       options
     end
   end
@@ -773,10 +1259,14 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
   def attributes_with_values_for(model)
     model_attributes[model].each_with_object({}) do |attribute, attrs|
       attrs[attribute[:name]] = attribute.fetch(:value) do
-        dummy_value_for(
-          attribute[:value_type],
-          array: attribute[:array]
-        )
+        if attribute[:options][:null]
+          nil
+        else
+          dummy_value_for(
+            attribute[:value_type],
+            array: attribute[:options][:array]
+          )
+        end
       end
     end
   end
@@ -835,25 +1325,21 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
     end
   end
 
-  def determine_scope_attribute_names_from(scope_attributes)
-    scope_attributes.map do |attribute|
-      if attribute.is_a?(Hash)
-        attribute[:name]
-      else
-        attribute
-      end
-    end
-  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 = {
+    attribute = normalize_attribute(
       name: attribute_name,
       value_type: attribute_type,
       column_type: attribute_type,
       options: attribute_options
-    }
+    )
+
+    if options.key?(:attribute_value)
+      attribute[:value] = options[:attribute_value]
+    end
+
     scope_attributes = normalize_attributes(options.fetch(:scopes, []))
     scope_attribute_names = scope_attributes.map { |attr| attr[:name] }
     additional_attributes = normalize_attributes(
@@ -909,6 +1395,12 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
     build_record_from(model)
   end
 
+  def define_model_without_validation
+    define_model(:example, attribute_name => :string) do |model|
+      model.attr_accessible(attribute_name)
+    end
+  end
+
   def validate_uniqueness
     validate_uniqueness_of(attribute_name)
   end
@@ -916,4 +1408,11 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
   def attribute_name
     :attr
   end
+
+  def validation_matcher_scenario_args
+    super.deep_merge(
+      matcher_name: :validate_uniqueness_of,
+      model_creator: :"active_record/uniqueness_matcher"
+    )
+  end
 end