shoulda-matchers 2.5.0 → 2.6.0

data/spec/shoulda/matchers/active_model/allow_value_matcher_spec.rb

@@ -5,70 +5,70 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
     it 'describes itself with multiple values' do
       matcher = allow_value('foo', 'bar').for(:baz)
 
-      matcher.description.should eq 'allow baz to be set to any of ["foo", "bar"]'
+      expect(matcher.description).to eq 'allow baz to be set to any of ["foo", "bar"]'
     end
 
     it 'describes itself with a single value' do
       matcher = allow_value('foo').for(:baz)
 
-      matcher.description.should eq 'allow baz to be set to "foo"'
+      expect(matcher.description).to eq 'allow baz to be set to "foo"'
     end
 
     if active_model_3_2?
       it 'describes itself with a strict validation' do
         strict_matcher = allow_value('xyz').for(:attr).strict
 
-        strict_matcher.description.
-          should eq %q(doesn't raise when attr is set to "xyz")
+        expect(strict_matcher.description).
+          to eq %q(doesn't raise when attr is set to "xyz")
       end
     end
   end
 
   context 'an attribute with a validation' do
     it 'allows a good value' do
-      validating_format(:with => /abc/).should allow_value('abcde').for(:attr)
+      expect(validating_format(with: /abc/)).to allow_value('abcde').for(:attr)
     end
 
     it 'rejects a bad value' do
-      validating_format(:with => /abc/).should_not allow_value('xyz').for(:attr)
+      expect(validating_format(with: /abc/)).not_to allow_value('xyz').for(:attr)
     end
 
     it 'allows several good values' do
-      validating_format(:with => /abc/).
-        should allow_value('abcde', 'deabc').for(:attr)
+      expect(validating_format(with: /abc/)).
+        to allow_value('abcde', 'deabc').for(:attr)
     end
 
     it 'rejects several bad values' do
-      validating_format(:with => /abc/).
-        should_not allow_value('xyz', 'zyx', nil, []).for(:attr)
+      expect(validating_format(with: /abc/)).
+        not_to allow_value('xyz', 'zyx', nil, []).for(:attr)
     end
   end
 
   context 'an attribute with a validation and a custom message' do
     it 'allows a good value' do
-      validating_format(:with => /abc/, :message => 'bad value').
-        should allow_value('abcde').for(:attr).with_message(/bad/)
+      expect(validating_format(with: /abc/, message: 'bad value')).
+        to allow_value('abcde').for(:attr).with_message(/bad/)
     end
 
     it 'rejects a bad value' do
-      validating_format(:with => /abc/, :message => 'bad value').
-        should_not allow_value('xyz').for(:attr).with_message(/bad/)
+      expect(validating_format(with: /abc/, message: 'bad value')).
+        not_to allow_value('xyz').for(:attr).with_message(/bad/)
     end
   end
 
   context 'an attribute where the message occurs on another attribute' do
     it 'allows a good value' do
-      record_with_custom_validation.should \
-        allow_value('good value').for(:attr).with_message(/some message/, :against => :attr2)
+      expect(record_with_custom_validation).to \
+        allow_value('good value').for(:attr).with_message(/some message/, against: :attr2)
     end
 
     it 'rejects a bad value' do
-      record_with_custom_validation.should_not \
-        allow_value('bad value').for(:attr).with_message(/some message/, :against => :attr2)
+      expect(record_with_custom_validation).not_to \
+        allow_value('bad value').for(:attr).with_message(/some message/, against: :attr2)
     end
 
     def record_with_custom_validation
-      define_model :example, :attr => :string, :attr2 => :string do
+      define_model :example, attr: :string, attr2: :string do
         validate :custom_validation
 
         def custom_validation
@@ -83,54 +83,54 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
   context "an attribute with a context-dependent validation" do
     context "without the validation context" do
       it "allows a bad value" do
-        validating_format(:with => /abc/, :on => :customisable).should allow_value("xyz").for(:attr)
+        expect(validating_format(with: /abc/, on: :customisable)).to allow_value("xyz").for(:attr)
       end
     end
 
     context "with the validation context" do
       it "allows a good value" do
-        validating_format(:with => /abc/, :on => :customisable).should allow_value("abcde").for(:attr).on(:customisable)
+        expect(validating_format(with: /abc/, on: :customisable)).to allow_value("abcde").for(:attr).on(:customisable)
       end
 
       it "rejects a bad value" do
-        validating_format(:with => /abc/, :on => :customisable).should_not allow_value("xyz").for(:attr).on(:customisable)
+        expect(validating_format(with: /abc/, on: :customisable)).not_to allow_value("xyz").for(:attr).on(:customisable)
       end
     end
   end
 
   context 'an attribute with several validations' do
     let(:model) do
-      define_model :example, :attr => :string do
+      define_model :example, attr: :string do
         validates_presence_of     :attr
-        validates_length_of       :attr, :within => 1..5
-        validates_numericality_of :attr, :greater_than_or_equal_to => 1,
-          :less_than_or_equal_to    => 50000
+        validates_length_of       :attr, within: 1..5
+        validates_numericality_of :attr, greater_than_or_equal_to: 1,
+          less_than_or_equal_to: 50000
       end.new
     end
     bad_values = [nil, '', 'abc', '0', '50001', '123456', []]
 
     it 'allows a good value' do
-      model.should allow_value('12345').for(:attr)
+      expect(model).to allow_value('12345').for(:attr)
     end
 
     bad_values.each do |bad_value|
       it "rejects a bad value (#{bad_value.inspect})" do
-        model.should_not allow_value(bad_value).for(:attr)
+        expect(model).not_to allow_value(bad_value).for(:attr)
       end
     end
 
     it "rejects several bad values (#{bad_values.map(&:inspect).join(', ')})" do
-      model.should_not allow_value(*bad_values).for(:attr)
+      expect(model).not_to allow_value(*bad_values).for(:attr)
     end
 
     it "rejects a mix of both good and bad values" do
-      model.should_not allow_value('12345', *bad_values).for(:attr)
+      expect(model).not_to allow_value('12345', *bad_values).for(:attr)
     end
   end
 
   context 'with a single value' do
     it 'allows you to call description before calling matches?' do
-      model = define_model(:example, :attr => :string).new
+      model = define_model(:example, attr: :string).new
       matcher = described_class.new('foo').for(:attr)
       matcher.description
 
@@ -148,21 +148,21 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
   if active_model_3_2?
     context 'an attribute with a strict format validation' do
       it 'strictly rejects a bad value' do
-        validating_format(:with => /abc/, :strict => true).
-          should_not allow_value('xyz').for(:attr).strict
+        expect(validating_format(with: /abc/, strict: true)).
+          not_to allow_value('xyz').for(:attr).strict
       end
 
       it 'strictly allows a bad value with a different message' do
-        validating_format(:with => /abc/, :strict => true).
-          should allow_value('xyz').for(:attr).with_message(/abc/).strict
+        expect(validating_format(with: /abc/, strict: true)).
+          to allow_value('xyz').for(:attr).with_message(/abc/).strict
       end
 
       it 'provides a useful negative failure message' do
         matcher = allow_value('xyz').for(:attr).strict.with_message(/abc/)
 
-        matcher.matches?(validating_format(:with => /abc/, :strict => true))
+        matcher.matches?(validating_format(with: /abc/, strict: true))
 
-        matcher.failure_message_when_negated.should eq 'Expected exception to include /abc/ ' +
+        expect(matcher.failure_message_when_negated).to eq 'Expected exception to include /abc/ ' +
           'when attr is set to "xyz", got Attr is invalid'
       end
     end

data/spec/shoulda/matchers/active_model/disallow_value_matcher_spec.rb

@@ -1,73 +1,69 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
-  it 'does not allow any types' do
-    matcher('abcde').allowed_types.should eq ''
-  end
-
   context 'an attribute with a format validation' do
     it 'does not match if the value is allowed' do
-      validating_format(:with => /abc/).should_not matcher('abcde').for(:attr)
+      expect(validating_format(with: /abc/)).not_to matcher('abcde').for(:attr)
     end
 
     it 'matches if the value is not allowed' do
-      validating_format(:with => /abc/).should matcher('xyz').for(:attr)
+      expect(validating_format(with: /abc/)).to matcher('xyz').for(:attr)
     end
   end
 
   context "an attribute with a context-dependent validation" do
     context "without the validation context" do
       it "does not match" do
-        validating_format(:with => /abc/, :on => :customisable).should_not matcher("xyz").for(:attr)
+        expect(validating_format(with: /abc/, on: :customisable)).not_to matcher("xyz").for(:attr)
       end
     end
 
     context "with the validation context" do
       it "disallows a bad value" do
-        validating_format(:with => /abc/, :on => :customisable).should matcher("xyz").for(:attr).on(:customisable)
+        expect(validating_format(with: /abc/, on: :customisable)).to matcher("xyz").for(:attr).on(:customisable)
       end
 
       it "does not match a good value" do
-        validating_format(:with => /abc/, :on => :customisable).should_not matcher("abcde").for(:attr).on(:customisable)
+        expect(validating_format(with: /abc/, on: :customisable)).not_to matcher("abcde").for(:attr).on(:customisable)
       end
     end
   end
 
   context 'an attribute with a format validation and a custom message' do
     it 'does not match if the value and message are both correct' do
-      validating_format(:with => /abc/, :message => 'good message').
-        should_not matcher('abcde').for(:attr).with_message('good message')
+      expect(validating_format(with: /abc/, message: 'good message')).
+        not_to matcher('abcde').for(:attr).with_message('good message')
     end
 
     it "delegates its failure message to its allow matcher's negative failure message" do
-      allow_matcher = stub_everything(:failure_message_when_negated => 'allow matcher failure')
+      allow_matcher = stub_everything(failure_message_when_negated: 'allow matcher failure')
       Shoulda::Matchers::ActiveModel::AllowValueMatcher.stubs(:new).returns(allow_matcher)
 
       matcher = matcher('abcde').for(:attr).with_message('good message')
-      matcher.matches?(validating_format(:with => /abc/, :message => 'good message'))
+      matcher.matches?(validating_format(with: /abc/, message: 'good message'))
 
-      matcher.failure_message.should eq 'allow matcher failure'
+      expect(matcher.failure_message).to eq 'allow matcher failure'
     end
 
     it 'matches if the message is correct but the value is not' do
-      validating_format(:with => /abc/, :message => 'good message').
-        should matcher('xyz').for(:attr).with_message('good message')
+      expect(validating_format(with: /abc/, message: 'good message')).
+        to matcher('xyz').for(:attr).with_message('good message')
     end
   end
 
   context 'an attribute where the message occurs on another attribute' do
     it 'matches if the message is correct but the value is not' do
-      record_with_custom_validation.should \
-        matcher('bad value').for(:attr).with_message(/some message/, :against => :attr2)
+      expect(record_with_custom_validation).to \
+        matcher('bad value').for(:attr).with_message(/some message/, against: :attr2)
     end
 
     it 'does not match if the value and message are both correct' do
-      record_with_custom_validation.should_not \
-        matcher('good value').for(:attr).with_message(/some message/, :against => :attr2)
+      expect(record_with_custom_validation).not_to \
+        matcher('good value').for(:attr).with_message(/some message/, against: :attr2)
     end
 
     def record_with_custom_validation
-      define_model :example, :attr => :string, :attr2 => :string do
+      define_model :example, attr: :string, attr2: :string do
         validate :custom_validation
 
         def custom_validation

data/spec/shoulda/matchers/active_model/ensure_exclusion_of_matcher_spec.rb

@@ -3,37 +3,37 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
   context 'an attribute which must be excluded from a range' do
     it 'accepts ensuring the correct range' do
-      validating_exclusion(:in => 2..5).
-        should ensure_exclusion_of(:attr).in_range(2..5)
+      expect(validating_exclusion(in: 2..5)).
+        to ensure_exclusion_of(:attr).in_range(2..5)
     end
 
     it 'rejects ensuring excluded value' do
-      validating_exclusion(:in => 2..5).
-        should_not ensure_exclusion_of(:attr).in_range(2..6)
+      expect(validating_exclusion(in: 2..5)).
+        not_to ensure_exclusion_of(:attr).in_range(2..6)
     end
 
     it 'does not override the default message with a blank' do
-      validating_exclusion(:in => 2..5).
-        should ensure_exclusion_of(:attr).in_range(2..5).with_message(nil)
+      expect(validating_exclusion(in: 2..5)).
+        to ensure_exclusion_of(:attr).in_range(2..5).with_message(nil)
     end
   end
 
   context 'an attribute which must be excluded from a range with excluded end' do
     it 'accepts ensuring the correct range' do
-      validating_exclusion(:in => 2...5).
-        should ensure_exclusion_of(:attr).in_range(2...5)
+      expect(validating_exclusion(in: 2...5)).
+        to ensure_exclusion_of(:attr).in_range(2...5)
     end
 
     it 'rejects ensuring excluded value' do
-      validating_exclusion(:in => 2...5).
-        should_not ensure_exclusion_of(:attr).in_range(2...4)
+      expect(validating_exclusion(in: 2...5)).
+        not_to ensure_exclusion_of(:attr).in_range(2...4)
     end
   end
 
   context 'an attribute with a custom validation message' do
     it 'accepts ensuring the correct range' do
-      validating_exclusion(:in => 2..4, :message => 'not good').
-        should ensure_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
+      expect(validating_exclusion(in: 2..4, message: 'not good')).
+        to ensure_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
     end
   end
 
@@ -45,7 +45,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
         end
       end
 
-      model.should ensure_exclusion_of(:attr).in_range(2..5).
+      expect(model).to ensure_exclusion_of(:attr).in_range(2..5).
         with_message(/should be out of this range/)
 
       model = custom_validation do
@@ -54,41 +54,41 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
         end
       end
 
-      model.should ensure_exclusion_of(:attr).in_range(2...5).
+      expect(model).to ensure_exclusion_of(:attr).in_range(2...5).
         with_message(/should be out of this range/)
     end
   end
 
   context 'an attribute which must be excluded from an array' do
     it 'accepts with correct array' do
-      validating_exclusion(:in => %w(one two)).
-        should ensure_exclusion_of(:attr).in_array(%w(one two))
+      expect(validating_exclusion(in: %w(one two))).
+        to ensure_exclusion_of(:attr).in_array(%w(one two))
     end
 
     it 'rejects when only part of array matches' do
-      validating_exclusion(:in => %w(one two)).
-        should_not ensure_exclusion_of(:attr).in_array(%w(one wrong_value))
+      expect(validating_exclusion(in: %w(one two))).
+        not_to ensure_exclusion_of(:attr).in_array(%w(one wrong_value))
     end
 
     it 'rejects when array does not match at all' do
-      validating_exclusion(:in => %w(one two)).
-        should_not ensure_exclusion_of(:attr).in_array(%w(cat dog))
+      expect(validating_exclusion(in: %w(one two))).
+        not_to ensure_exclusion_of(:attr).in_array(%w(cat dog))
     end
 
     it 'has correct description' do
-      ensure_exclusion_of(:attr).in_array([true, 'dog']).description.
-        should eq 'ensure exclusion of attr in [true, "dog"]'
+      expect(ensure_exclusion_of(:attr).in_array([true, 'dog']).description).
+        to eq 'ensure exclusion of attr in [true, "dog"]'
     end
 
     def validating_exclusion(options)
-      define_model(:example, :attr => :string) do
+      define_model(:example, attr: :string) do
         validates_exclusion_of :attr, options
       end.new
     end
   end
 
   def validating_exclusion(options)
-    define_model(:example, :attr => :integer) do
+    define_model(:example, attr: :integer) do
       validates_exclusion_of :attr, options
     end.new
   end

data/spec/shoulda/matchers/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -3,95 +3,95 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
   context 'with no validations' do
     it 'rejects an array which does not have a validator defined' do
-      define_model(:example, :attr => :string).new.
-        should_not ensure_inclusion_of(:attr).in_array(%w(Yes No))
+      expect(define_model(:example, attr: :string).new).
+        not_to ensure_inclusion_of(:attr).in_array(%w(Yes No))
     end
   end
 
   context 'with an integer column' do
     it 'can verify a zero in the array' do
-      model = define_model(:example, :attr => :integer) do
-        validates_inclusion_of :attr, :in => [0, 1, 2]
+      model = define_model(:example, attr: :integer) do
+        validates_inclusion_of :attr, in: [0, 1, 2]
       end.new
 
-      model.should ensure_inclusion_of(:attr).in_array([0,1,2])
+      expect(model).to ensure_inclusion_of(:attr).in_array([0,1,2])
     end
   end
 
   context 'with an decimal column' do
     it 'can verify decimal values' do
-      model = define_model(:example, :attr => :decimal) do
-        validates_inclusion_of :attr, :in => [0.0, 0.1]
+      model = define_model(:example, attr: :decimal) do
+        validates_inclusion_of :attr, in: [0.0, 0.1]
       end.new
 
-      model.should ensure_inclusion_of(:attr).in_array([0.0, 0.1])
+      expect(model).to ensure_inclusion_of(:attr).in_array([0.0, 0.1])
     end
   end
 
   context 'with true/false values' do
     it 'can verify outside values to ensure the negative case' do
-      define_model(:example, :attr => :string).new.
-        should_not ensure_inclusion_of(:attr).in_array([true, false])
+      expect(define_model(:example, attr: :string).new).
+        not_to ensure_inclusion_of(:attr).in_array([true, false])
     end
   end
 
   context 'where we cannot determine a value outside the array' do
     it 'raises a custom exception' do
-      model = define_model(:example, :attr => :string).new
+      model = define_model(:example, attr: :string).new
 
       arbitrary_string = described_class::ARBITRARY_OUTSIDE_STRING
-      expect { model.should ensure_inclusion_of(:attr).in_array([arbitrary_string]) }.to raise_error Shoulda::Matchers::ActiveModel::CouldNotDetermineValueOutsideOfArray
+      expect { expect(model).to ensure_inclusion_of(:attr).in_array([arbitrary_string]) }.to raise_error Shoulda::Matchers::ActiveModel::CouldNotDetermineValueOutsideOfArray
     end
   end
 
   context 'an attribute which must be included in a range' do
     it 'accepts ensuring the correct range' do
-      validating_inclusion(:in => 2..5).
-        should ensure_inclusion_of(:attr).in_range(2..5)
+      expect(validating_inclusion(in: 2..5)).
+        to ensure_inclusion_of(:attr).in_range(2..5)
     end
 
     it 'rejects ensuring a lower minimum value' do
-      validating_inclusion(:in => 2..5).
-        should_not ensure_inclusion_of(:attr).in_range(1..5)
+      expect(validating_inclusion(in: 2..5)).
+        not_to ensure_inclusion_of(:attr).in_range(1..5)
     end
 
     it 'rejects ensuring a higher minimum value' do
-      validating_inclusion(:in => 2..5).
-        should_not ensure_inclusion_of(:attr).in_range(3..5)
+      expect(validating_inclusion(in: 2..5)).
+        not_to ensure_inclusion_of(:attr).in_range(3..5)
     end
 
     it 'rejects ensuring a lower maximum value' do
-      validating_inclusion(:in => 2..5).
-        should_not ensure_inclusion_of(:attr).in_range(2..4)
+      expect(validating_inclusion(in: 2..5)).
+        not_to ensure_inclusion_of(:attr).in_range(2..4)
     end
 
     it 'rejects ensuring a higher maximum value' do
-      validating_inclusion(:in => 2..5).
-        should_not ensure_inclusion_of(:attr).in_range(2..6)
+      expect(validating_inclusion(in: 2..5)).
+        not_to ensure_inclusion_of(:attr).in_range(2..6)
     end
 
     it 'does not override the default message with a blank' do
-      validating_inclusion(:in => 2..5).
-        should ensure_inclusion_of(:attr).in_range(2..5).with_message(nil)
+      expect(validating_inclusion(in: 2..5)).
+        to ensure_inclusion_of(:attr).in_range(2..5).with_message(nil)
     end
   end
 
   context 'an attribute which must be included in a range with excluded end' do
     it 'accepts ensuring the correct range' do
-      validating_inclusion(:in => 2...5).
-        should ensure_inclusion_of(:attr).in_range(2...5)
+      expect(validating_inclusion(in: 2...5)).
+        to ensure_inclusion_of(:attr).in_range(2...5)
     end
 
     it 'rejects ensuring a lower maximum value' do
-      validating_inclusion(:in => 2...5).
-        should_not ensure_inclusion_of(:attr).in_range(2...4)
+      expect(validating_inclusion(in: 2...5)).
+        not_to ensure_inclusion_of(:attr).in_range(2...4)
     end
   end
 
   context 'an attribute with a custom ranged value validation' do
     it 'accepts ensuring the correct range' do
-      validating_inclusion(:in => 2..4, :message => 'not good').
-        should ensure_inclusion_of(:attr).in_range(2..4).with_message(/not good/)
+      expect(validating_inclusion(in: 2..4, message: 'not good')).
+        to ensure_inclusion_of(:attr).in_range(2..4).with_message(/not good/)
     end
   end
 
@@ -105,7 +105,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
         end
       end
 
-      model.should ensure_inclusion_of(:attr).in_range(2..5).
+      expect(model).to ensure_inclusion_of(:attr).in_range(2..5).
         with_low_message(/low/).with_high_message(/high/)
 
       model = custom_validation do
@@ -116,99 +116,205 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
         end
       end
 
-      model.should ensure_inclusion_of(:attr).in_range(2...5).
+      expect(model).to ensure_inclusion_of(:attr).in_range(2...5).
         with_low_message(/low/).with_high_message(/high/)
     end
   end
 
   context 'an attribute which must be included in an array' do
     it 'accepts with correct array' do
-      validating_inclusion(:in => %w(one two)).
-        should ensure_inclusion_of(:attr).in_array(%w(one two))
+      expect(validating_inclusion(in: %w(one two))).
+        to ensure_inclusion_of(:attr).in_array(%w(one two))
     end
 
     it 'rejects when only part of array matches' do
-      validating_inclusion(:in => %w(one two)).
-        should_not ensure_inclusion_of(:attr).in_array(%w(one wrong_value))
+      expect(validating_inclusion(in: %w(one two))).
+        not_to ensure_inclusion_of(:attr).in_array(%w(one wrong_value))
     end
 
     it 'rejects when array does not match at all' do
-      validating_inclusion(:in => %w(one two)).
-        should_not ensure_inclusion_of(:attr).in_array(%w(cat dog))
+      expect(validating_inclusion(in: %w(one two))).
+        not_to ensure_inclusion_of(:attr).in_array(%w(cat dog))
     end
 
     it 'has correct description' do
-      ensure_inclusion_of(:attr).in_array([true, "dog"]).description.
-        should eq 'ensure inclusion of attr in [true, "dog"]'
+      expect(ensure_inclusion_of(:attr).in_array([true, "dog"]).description).
+        to eq 'ensure inclusion of attr in [true, "dog"]'
     end
 
     it 'rejects allow_blank' do
-      validating_inclusion(:in => %w(one two)).
-        should_not ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(true)
+      expect(validating_inclusion(in: %w(one two))).
+        not_to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(true)
     end
 
     it 'accepts allow_blank(false)' do
-      validating_inclusion(:in => %w(one two)).
-        should ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(false)
+      expect(validating_inclusion(in: %w(one two))).
+        to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(false)
     end
 
     it 'rejects allow_nil' do
-      validating_inclusion(:in => %w(one two)).
-        should_not ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(true)
+      expect(validating_inclusion(in: %w(one two))).
+        not_to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(true)
     end
 
     it 'accepts allow_nil(false)' do
-      validating_inclusion(:in => %w(one two)).
-        should ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(false)
+      expect(validating_inclusion(in: %w(one two))).
+        to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(false)
     end
   end
 
   context 'with allowed blank and allowed nil' do
     it 'accepts allow_blank' do
-      validating_inclusion(:in => %w(one two), :allow_blank => true).
-        should ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank
+      expect(validating_inclusion(in: %w(one two), allow_blank: true)).
+        to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank
     end
 
     it 'rejects allow_blank(false)' do
-      validating_inclusion(:in => %w(one two), :allow_blank => true).
-        should_not ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(false)
+      expect(validating_inclusion(in: %w(one two), allow_blank: true)).
+        not_to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_blank(false)
     end
 
     it 'accepts allow_nil' do
-      validating_inclusion(:in => %w(one two), :allow_nil => true).
-        should ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil
+      expect(validating_inclusion(in: %w(one two), allow_nil: true)).
+        to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil
     end
 
     it 'rejects allow_nil' do
-      validating_inclusion(:in => %w(one two), :allow_nil => true).
-        should_not ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(false)
+      expect(validating_inclusion(in: %w(one two), allow_nil: true)).
+        not_to ensure_inclusion_of(:attr).in_array(%w(one two)).allow_nil(false)
     end
   end
 
   context 'an attribute allowing some blank values but not others' do
     it 'rejects allow_blank' do
-      validating_inclusion(:in => ['one', 'two', '']).
-        should_not ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(true)
+      expect(validating_inclusion(in: ['one', 'two', ''])).
+        not_to ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(true)
     end
   end
 
   if active_model_3_2?
     context 'a strict attribute which must be included in a range' do
       it 'accepts ensuring the correct range' do
-        validating_inclusion(:in => 2..5, :strict => true).
-          should ensure_inclusion_of(:attr).in_range(2..5).strict
+        expect(validating_inclusion(in: 2..5, strict: true)).
+          to ensure_inclusion_of(:attr).in_range(2..5).strict
       end
 
       it 'rejects ensuring another range' do
-        validating_inclusion(:in => 2..5, :strict => true).
-          should_not ensure_inclusion_of(:attr).in_range(2..6).strict
+        expect(validating_inclusion(in: 2..5, strict: true)).
+          not_to ensure_inclusion_of(:attr).in_range(2..6).strict
       end
     end
   end
-end
 
-def validating_inclusion(options)
-  define_model(:example, :attr => :string) do
-    validates_inclusion_of :attr, options
-  end.new
+  context 'against a boolean attribute' do
+    context 'which is nullable' do
+      context 'when ensuring inclusion of true' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [true], null: true)
+          expect(record).to ensure_inclusion_of(:attr).in_array([true])
+        end
+      end
+
+      context 'when ensuring inclusion of false' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [false], null: true)
+          expect(record).to ensure_inclusion_of(:attr).in_array([false])
+        end
+      end
+
+      context 'when ensuring inclusion of true and false' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [true, false], null: true)
+          capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([true, false])
+          end
+        end
+
+        it 'prints a warning' do
+          record = validating_inclusion_of_boolean_in(:attr, [true, false], null: true)
+          stderr = capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([true, false])
+          end
+          expect(stderr.gsub(/\n+/, ' ')).
+            to include('You are using `ensure_inclusion_of` to assert that a boolean column allows boolean values and disallows non-boolean ones')
+        end
+      end
+
+      context 'when ensuring inclusion of nil' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [nil], null: true)
+          capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([nil])
+          end
+        end
+
+        it 'prints a warning' do
+          record = validating_inclusion_of_boolean_in(:attr, [nil], null: true)
+          stderr = capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([nil])
+          end
+          expect(stderr.gsub(/\n+/, ' ')).
+            to include('You are using `ensure_inclusion_of` to assert that a boolean column allows nil')
+        end
+      end
+    end
+
+    context 'which is non-nullable' do
+      context 'when ensuring inclusion of true' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [true], null: false)
+          expect(record).to ensure_inclusion_of(:attr).in_array([true])
+        end
+      end
+
+      context 'when ensuring inclusion of false' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [false], null: false)
+          expect(record).to ensure_inclusion_of(:attr).in_array([false])
+        end
+      end
+
+      context 'when ensuring inclusion of true and false' do
+        it "doesn't raise an error" do
+          record = validating_inclusion_of_boolean_in(:attr, [true, false], null: false)
+          capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([true, false])
+          end
+        end
+
+        it 'prints a warning' do
+          record = validating_inclusion_of_boolean_in(:attr, [true, false], null: false)
+          stderr = capture(:stderr) do
+            expect(record).to ensure_inclusion_of(:attr).in_array([true, false])
+          end
+          expect(stderr.gsub(/\n+/, ' ')).
+            to include('You are using `ensure_inclusion_of` to assert that a boolean column allows boolean values and disallows non-boolean ones')
+        end
+      end
+
+      context 'when ensuring inclusion of nil' do
+        it 'raises a specific error' do
+          record = validating_inclusion_of_boolean_in(:attr, [nil], null: false)
+          error_class = Shoulda::Matchers::ActiveModel::NonNullableBooleanError
+          expect {
+            expect(record).to ensure_inclusion_of(:attr).in_array([nil])
+          }.to raise_error(error_class)
+        end
+      end
+    end
+  end
+
+  def validating_inclusion(options)
+    define_model(:example, attr: :string) do
+      validates_inclusion_of :attr, options
+    end.new
+  end
+
+  def validating_inclusion_of_boolean_in(attribute, values, options = {})
+    null = options.fetch(:null, true)
+    column_options = { type: :boolean, options: { null: null } }
+    define_model(:example, attribute => column_options) do
+      validates_inclusion_of attribute, in: values
+    end.new
+  end
 end