shoulda-matchers 3.0.0.rc1 → 3.0.0

data/lib/shoulda/matchers/action_controller/redirect_to_matcher.rb

@@ -3,7 +3,7 @@ module Shoulda
     module ActionController
       # The `redirect_to` matcher tests that an action redirects to a certain
       # location. In a test suite using RSpec, it is very similar to
-      # rspec-rails's `redirect_to` matcher. In a test suite using Test::Unit /
+      # rspec-rails's `redirect_to` matcher. In a test suite using Minitest +
       # Shoulda, it provides a more expressive syntax over
       # `assert_redirected_to`.
       #
@@ -23,7 +23,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #show' do
       #         setup { get :show }
@@ -43,9 +43,6 @@ module Shoulda
       class RedirectToMatcher
         attr_reader :failure_message, :failure_message_when_negated
 
-        alias failure_message_for_should failure_message
-        alias failure_message_for_should_not failure_message_when_negated
-
         def initialize(url_or_description, context, &block)
           @url_block = nil
           @url = nil

data/lib/shoulda/matchers/action_controller/render_template_matcher.rb

@@ -3,8 +3,8 @@ module Shoulda
     module ActionController
       # The `render_template` matcher tests that an action renders a template
       # or partial. In RSpec, it is very similar to rspec-rails's
-      # `render_template` matcher. In Test::Unit, it provides a more expressive
-      # syntax over `assert_template`.
+      # `render_template` matcher. In a test suite using Minitest + Shoulda, it
+      # provides a more expressive syntax over `assert_template`.
       #
       #     class PostsController < ApplicationController
       #       def show
@@ -20,22 +20,20 @@ module Shoulda
       #         before { get :show }
       #
       #         it { should render_template('show') }
-      #         it { should render_template(partial: 'sidebar') }
+      #         it { should render_template(partial: '_sidebar') }
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #show' do
       #         setup { get :show }
       #
       #         should render_template('show')
-      #         should render_template(partial: 'sidebar')
+      #         should render_template(partial: '_sidebar')
       #       end
       #     end
       #
-      # 
-      #
       # @return [RenderTemplateMatcher]
       #
       def render_template(options = {}, message = nil)
@@ -46,9 +44,6 @@ module Shoulda
       class RenderTemplateMatcher
         attr_reader :failure_message, :failure_message_when_negated
 
-        alias failure_message_for_should failure_message
-        alias failure_message_for_should_not failure_message_when_negated
-
         def initialize(options, message, context)
           @options = options
           @message = message

data/lib/shoulda/matchers/action_controller/render_with_layout_matcher.rb

@@ -19,7 +19,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #show' do
       #         setup { get :show }
@@ -46,7 +46,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #sidebar' do
       #         setup { get :sidebar }
@@ -88,12 +88,10 @@ module Shoulda
         def failure_message
           "Expected #{expectation}, but #{result}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Did not expect #{expectation}, but #{result}"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           description = 'render with '

data/lib/shoulda/matchers/action_controller/rescue_from_matcher.rb

@@ -23,7 +23,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class ApplicationControllerTest < ActionController::TestCase
       #       should rescue_from(ActiveRecord::RecordNotFound).
       #         with(:handle_not_found)
@@ -62,12 +62,10 @@ module Shoulda
         def failure_message
           "Expected #{expectation}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Did not expect #{expectation}"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         protected
 

data/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -21,7 +21,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :index }
@@ -47,7 +47,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'DELETE #destroy' do
       #         setup { delete :destroy }
@@ -73,7 +73,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #show' do
       #         setup { get :show }
@@ -102,12 +102,10 @@ module Shoulda
         def failure_message
           "Expected #{expectation}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Did not expect #{expectation}"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           "respond with #{@status}"

data/lib/shoulda/matchers/action_controller/route_matcher.rb

@@ -4,8 +4,9 @@ module Shoulda
       # The `route` matcher tests that a route resolves to a controller,
       # action, and params; and that the controller, action, and params
       # generates the same route. For an RSpec suite, this is like using a
-      # combination of `route_to` and `be_routable`. For a Test::Unit suite, it
-      # provides a more expressive syntax over `assert_routing`.
+      # combination of `route_to` and `be_routable`. In a test suite using
+      # Minitest + Shoulda, it provides a more expressive syntax over
+      # `assert_routing`.
       #
       # You can use this matcher either in a controller test case or in a
       # routing test case. For instance, given these routes:
@@ -28,7 +29,7 @@ module Shoulda
       #       it { should route(:get, '/posts/1').to(action: :show, id: 1) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       should route(:get, '/posts').to(action: 'index')
       #       should route(:get, '/posts/1').to(action: :show, id: 1)
@@ -49,7 +50,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class RoutesTest < ActionController::IntegrationTest
       #       should route(:get, '/posts').
       #         to(controller: :posts, action: :index)
@@ -99,9 +100,6 @@ module Shoulda
 
         attr_reader :failure_message, :failure_message_when_negated
 
-        alias failure_message_for_should failure_message
-        alias failure_message_for_should_not failure_message_when_negated
-
         def to(*args)
           @params = RouteParams.new(args).normalize
           self

data/lib/shoulda/matchers/action_controller/set_flash_matcher.rb

@@ -30,7 +30,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :index }
@@ -67,7 +67,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :show }
@@ -100,7 +100,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :show }
@@ -129,19 +129,19 @@ module Shoulda
       #         before { get :show }
       #
       #         it { should set_flash.now }
-      #         it { should set_flash[:foo].now }
-      #         it { should set_flash[:foo].to('bar').now }
+      #         it { should set_flash.now[:foo] }
+      #         it { should set_flash.now[:foo].to('bar') }
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :show }
       #
       #         should set_flash.now
-      #         should set_flash[:foo].now
-      #         should set_flash[:foo].to('bar').now
+      #         should set_flash.now[:foo]
+      #         should set_flash.now[:foo].to('bar')
       #       end
       #     end
       #
@@ -173,6 +173,10 @@ module Shoulda
         end
 
         def now
+          if key || expected_value
+            raise QualifierOrderError
+          end
+
           store = FlashStore.now
           @underlying_matcher = SetSessionOrFlashMatcher.new(store)
           self
@@ -184,18 +188,40 @@ module Shoulda
         end
 
         def [](key)
+          @key = key
           underlying_matcher[key]
           self
         end
 
         def to(expected_value = nil, &block)
+          @expected_value = expected_value
           underlying_matcher.to(expected_value, &block)
           self
         end
 
         protected
 
-        attr_reader :underlying_matcher
+        attr_reader :underlying_matcher, :key, :expected_value
+
+        # @private
+        class QualifierOrderError < StandardError
+          def message
+            <<-MESSAGE.strip
+Using `set_flash` with the `now` qualifier and specifying `now` after other
+qualifiers is no longer allowed.
+
+You'll want to use `now` immediately after `set_flash`. For instance:
+
+    # Valid
+    should set_flash.now[:foo]
+    should set_flash.now[:foo].to('bar')
+
+    # Invalid
+    should set_flash[:foo].now
+    should set_flash[:foo].to('bar').now
+            MESSAGE
+          end
+        end
       end
     end
   end

data/lib/shoulda/matchers/action_controller/set_session_matcher.rb

@@ -30,7 +30,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :index }
@@ -67,7 +67,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :show }
@@ -100,7 +100,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostsControllerTest < ActionController::TestCase
       #       context 'GET #index' do
       #         setup { get :show }

data/lib/shoulda/matchers/active_model.rb

@@ -2,7 +2,6 @@ require 'shoulda/matchers/active_model/helpers'
 require 'shoulda/matchers/active_model/validation_matcher'
 require 'shoulda/matchers/active_model/validator'
 require 'shoulda/matchers/active_model/strict_validator'
-require 'shoulda/matchers/active_model/validator_with_captured_range_error'
 require 'shoulda/matchers/active_model/allow_value_matcher'
 require 'shoulda/matchers/active_model/disallow_value_matcher'
 require 'shoulda/matchers/active_model/validate_length_of_matcher'
@@ -24,6 +23,63 @@ require 'shoulda/matchers/active_model/have_secure_password_matcher'
 
 module Shoulda
   module Matchers
+    # This mixin provides matchers that are used to test behavior, such as
+    # validations, that you've added to your ActiveModel (or ActiveRecord)
+    # objects.
+    #
+    # ### Testing conditional validations
+    #
+    # If your model defines a validation conditionally -- meaning that the
+    # validation is declared with an `:if` or `:unless` option -- how do you
+    # test it? You might expect the validation matchers here to have
+    # corresponding `if` or `unless` qualifiers, but this isn't what you use.
+    # Instead, before using the matcher in question, you place the record
+    # you're testing in a state such that the validation you're also testing
+    # will be run. A common way to do this is to make a new `context` and
+    # override the subject to populate the record accordingly. You'll also want
+    # to make sure to test that the validation is *not* run when the
+    # conditional fails.
+    #
+    # Here's an example to illustrate what we mean:
+    #
+    #     class User
+    #       include ActiveModel::Model
+    #
+    #       attr_accessor :role, :admin
+    #
+    #       validates_presence_of :role, if: :admin
+    #     end
+    #
+    #     # RSpec
+    #     describe User do
+    #       context "when an admin" do
+    #         subject { User.new(admin: true) }
+    #
+    #         it { should validate_presence_of(:role) }
+    #       end
+    #
+    #       context "when not an admin" do
+    #         subject { User.new(admin: false) }
+    #
+    #         it { should_not validate_presence_of(:role) }
+    #       end
+    #     end
+    #
+    #     # Minitest (Shoulda)
+    #     class UserTest < ActiveSupport::TestCase
+    #       context "when an admin" do
+    #         subject { User.new(admin: true) }
+    #
+    #         should validate_presence_of(:role)
+    #       end
+    #
+    #       context "when not an admin" do
+    #         subject { User.new(admin: false) }
+    #
+    #         should_not validate_presence_of(:role)
+    #       end
+    #     end
+    #
     module ActiveModel
     end
   end

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

@@ -31,7 +31,7 @@ module Shoulda
       #       it { should_not allow_mass_assignment_of(:encrypted_password) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostTest < ActiveSupport::TestCase
       #       should allow_mass_assignment_of(:title)
       #     end
@@ -60,7 +60,7 @@ module Shoulda
       #       it { should allow_mass_assignment_of(:title).as(:admin) }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class PostTest < ActiveSupport::TestCase
       #       should allow_mass_assignment_of(:title).as(:admin)
       #     end
@@ -75,9 +75,6 @@ module Shoulda
       class AllowMassAssignmentOfMatcher
         attr_reader :failure_message, :failure_message_when_negated
 
-        alias failure_message_for_should failure_message
-        alias failure_message_for_should_not failure_message_when_negated
-
         def initialize(attribute)
           @attribute = attribute.to_s
           @options = {}

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

@@ -1,15 +1,11 @@
 module Shoulda
   module Matchers
     module ActiveModel
-      # The `allow_value` matcher is used to test that an attribute of a model
-      # can or cannot be set to a particular value or values. It is most
-      # commonly used in conjunction with the `validates_format_of` validation.
+      # The `allow_value` matcher (or its alias, `allow_values`) is used to
+      # ensure that an attribute is valid or invalid if set to one or more
+      # values.
       #
-      # #### should
-      #
-      # In the positive form, `allow_value` asserts that an attribute can be
-      # set to one or more values, succeeding if none of the values cause the
-      # record to be invalid:
+      # Take this model for example:
       #
       #     class UserProfile
       #       include ActiveModel::Model
@@ -18,45 +14,136 @@ module Shoulda
       #       validates_format_of :website_url, with: URI.regexp
       #     end
       #
+      # You can use `allow_value` to test one value at a time:
+      #
+      #     # RSpec
+      #     describe UserProfile do
+      #       it { should allow_value('http://foo.com').for(:website_url) }
+      #       it { should allow_value('http://bar.com').for(:website_url) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('http://foo.com').for(:website_url)
+      #       should allow_value('http://bar.com').for(:website_url)
+      #     end
+      #
+      # You can also test multiple values in one go, if you like. In the
+      # positive sense, this makes an assertion that none of the values cause the
+      # record to be invalid. In the negative sense, this makes an assertion
+      # that none of the values cause the record to be valid:
+      #
       #     # RSpec
       #     describe UserProfile do
       #       it do
-      #         should allow_value('http://foo.com', 'http://bar.com/baz').
+      #         should allow_values('http://foo.com', 'http://bar.com').
+      #           for(:website_url)
+      #       end
+      #
+      #       it do
+      #         should_not allow_values('http://foo.com', 'buz').
       #           for(:website_url)
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
-      #       should allow_value('http://foo.com', 'http://bar.com/baz').
+      #       should allow_values('http://foo.com', 'http://bar.com/baz').
+      #         for(:website_url)
+      #
+      #       should_not allow_values('http://foo.com', 'buz').
       #         for(:website_url)
       #     end
       #
-      # #### should_not
+      # #### Caveats
       #
-      # In the negative form, `allow_value` asserts that an attribute cannot be
-      # set to one or more values, succeeding if the *first* value causes the
-      # record to be invalid.
+      # When using `allow_value` or any matchers that depend on it, you may
+      # encounter a CouldNotSetAttributeError. This exception is raised if the
+      # matcher, in attempting to set a value on the attribute, detects that
+      # the value set is different from the value that the attribute returns
+      # upon reading it back.
       #
-      # **This can be surprising** so in this case if you need to check that
-      # *all* of the values are invalid, use separate assertions:
+      # This usually happens if the writer method (`foo=`, `bar=`, etc.) for
+      # that attribute has custom logic to ignore certain incoming values or
+      # change them in any way. Here are three examples we've seen:
       #
-      #     class UserProfile
-      #       include ActiveModel::Model
-      #       attr_accessor :website_url
+      # * You're attempting to assert that an attribute should not allow nil,
+      #   yet the attribute's writer method contains a conditional to do nothing
+      #   if the attribute is set to nil:
       #
-      #       validates_format_of :website_url, with: URI.regexp
-      #     end
+      #         class Foo
+      #           include ActiveModel::Model
       #
-      #     describe UserProfile do
-      #       # One assertion: 'buz' and 'bar' will not be tested
-      #       it { should_not allow_value('fiz', 'buz', 'bar').for(:website_url) }
+      #           attr_reader :bar
       #
-      #       # Three assertions, all tested separately
-      #       it { should_not allow_value('fiz').for(:website_url) }
-      #       it { should_not allow_value('buz').for(:website_url) }
-      #       it { should_not allow_value('bar').for(:website_url) }
-      #     end
+      #           def bar=(value)
+      #             return if value.nil?
+      #             @bar = value
+      #           end
+      #         end
+      #
+      #         describe Foo do
+      #           it do
+      #             foo = Foo.new
+      #             foo.bar = "baz"
+      #             # This will raise a CouldNotSetAttributeError since `foo.bar` is now "123"
+      #             expect(foo).not_to allow_value(nil).for(:bar)
+      #           end
+      #         end
+      #
+      # * You're attempting to assert that an numeric attribute should not allow a
+      #   string that contains non-numeric characters, yet the writer method for
+      #   that attribute strips out non-numeric characters:
+      #
+      #         class Foo
+      #           include ActiveModel::Model
+      #
+      #           attr_reader :bar
+      #
+      #           def bar=(value)
+      #             @bar = value.gsub(/\D+/, '')
+      #           end
+      #         end
+      #
+      #         describe Foo do
+      #           it do
+      #             foo = Foo.new
+      #             # This will raise a CouldNotSetAttributeError since `foo.bar` is now "123"
+      #             expect(foo).not_to allow_value("abc123").for(:bar)
+      #           end
+      #         end
+      #
+      # * You're passing a value to `allow_value` that the model typecasts into
+      #   another value:
+      #
+      #         describe Foo do
+      #           # Assume that `attr` is a string
+      #           # This will raise a CouldNotSetAttributeError since `attr` typecasts `[]` to `"[]"`
+      #           it { should_not allow_value([]).for(:attr) }
+      #         end
+      #
+      # So when you encounter this exception, you have a couple of options:
+      #
+      # * If you understand the problem and wish to override this behavior to
+      #   get around this exception, you can add the
+      #   `ignoring_interference_by_writer` qualifier like so:
+      #
+      #         it do
+      #           should_not allow_value([]).
+      #             for(:attr).
+      #             ignoring_interference_by_writer
+      #         end
+      #
+      # * Note, however, that the above option will not always cause the test to
+      #   pass. In this case, this is telling you that you don't need to use
+      #   `allow_value`, or quite possibly even the validation that you're
+      #   testing altogether. In any case, we would probably make the argument
+      #   that since it's clear that something is responsible for sanitizing
+      #   incoming data before it's stored in your model, there's no need to
+      #   ensure that sanitization places the model in a valid state, if such
+      #   sanitization creates valid data. In terms of testing, the sanitization
+      #   code should probably be tested, but not the effects of that
+      #   sanitization on the validness of the model.
       #
       # #### Qualifiers
       #
@@ -82,7 +169,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
       #       should allow_value('2013-01-01').
       #         for(:birthday_as_string).
@@ -111,7 +198,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
       #       should allow_value('open', 'closed').
       #         for(:state).
@@ -138,7 +225,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
       #       should allow_value('open', 'closed').
       #         for(:state).
@@ -176,7 +263,7 @@ module Shoulda
       #       end
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserProfileTest < ActiveSupport::TestCase
       #       should allow_value('Broncos', 'Titans').
       #         for(:sports_team).
@@ -185,6 +272,32 @@ module Shoulda
       #         )
       #     end
       #
+      # ##### ignoring_interference_by_writer
+      #
+      # Use `ignoring_interference_by_writer` if you've encountered a
+      # CouldNotSetAttributeError and wish to ignore it. Please read the Caveats
+      # section above for more information.
+      #
+      #     class Address < ActiveRecord::Base
+      #       # Address has a zip_code field which is a string
+      #     end
+      #
+      #     # RSpec
+      #     describe Address do
+      #       it do
+      #         should_not allow_value([]).
+      #         for(:zip_code).
+      #         ignoring_interference_by_writer
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class AddressTest < ActiveSupport::TestCase
+      #       should_not allow_value([]).
+      #       for(:zip_code).
+      #       ignoring_interference_by_writer
+      #     end
+      #
       # @return [AllowValueMatcher]
       #
       def allow_value(*values)
@@ -194,6 +307,7 @@ module Shoulda
           AllowValueMatcher.new(*values)
         end
       end
+      # @private
       alias_method :allow_values, :allow_value
 
       # @private
@@ -226,6 +340,7 @@ module Shoulda
           self.options = {}
           self.after_setting_value_callback = -> {}
           self.validator = Validator.new
+          @ignoring_interference_by_writer = false
         end
 
         def for(attribute)
@@ -255,6 +370,11 @@ module Shoulda
           self
         end
 
+        def ignoring_interference_by_writer
+          @ignoring_interference_by_writer = true
+          self
+        end
+
         def _after_setting_value(&callback)
           self.after_setting_value_callback = callback
         end
@@ -272,12 +392,10 @@ module Shoulda
         def failure_message
           "Did not expect #{expectation},\ngot#{error_description}"
         end
-        alias failure_message_for_should failure_message
 
         def failure_message_when_negated
           "Expected #{expectation},\ngot#{error_description}"
         end
-        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           validator.allow_description(allowed_values)
@@ -299,6 +417,10 @@ module Shoulda
           validator.attribute = attribute
         end
 
+        def ignoring_interference_by_writer?
+          @ignoring_interference_by_writer
+        end
+
         def value_matches?(value)
           self.value = value
           set_attribute(value)
@@ -306,29 +428,15 @@ module Shoulda
         end
 
         def set_attribute(value)
-          set_attribute_ignoring_range_errors(value)
-          after_setting_value_callback.call
-        end
-
-        def set_attribute_ignoring_range_errors(value)
           instance.__send__("#{attribute_to_set}=", value)
-          ensure_that_attribute_has_been_changed_to_or_from_nil!(value)
-        rescue RangeError => exception
-          # Have to reset the attribute so that we don't get a RangeError the
-          # next time we attempt to write the attribute (ActiveRecord seems to
-          # set the attribute to the "bad" value anyway)
-          reset_attribute
-          validator.capture_range_error(exception)
-        end
-
-        def reset_attribute
-          instance.send(:raw_write_attribute, attribute_to_set, nil)
+          ensure_that_attribute_was_set!(value)
+          after_setting_value_callback.call
         end
 
-        def ensure_that_attribute_has_been_changed_to_or_from_nil!(expected_value)
+        def ensure_that_attribute_was_set!(expected_value)
           actual_value = instance.__send__(attribute_to_set)
 
-          if expected_value.nil? != actual_value.nil?
+          if expected_value != actual_value && !ignoring_interference_by_writer?
             raise CouldNotSetAttributeError.create(
               instance.class,
               attribute_to_set,