shoulda-matchers 1.4.2 → 1.5.0

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

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
+  context '#description' do
+    context 'without a role' do
+      it 'includes the attribute name' do
+        described_class.new(:attr).description.should ==
+          'allow mass assignment of attr'
+      end
+    end
+
+    if active_model_3_1?
+      context 'with a role' do
+        it 'includes the attribute name and the role' do
+          described_class.new(:attr).as(:admin).description.should ==
+            'allow mass assignment of attr as admin'
+        end
+      end
+    end
+  end
+
+  context 'an attribute that is blacklisted from mass-assignment' do
+    it 'rejects being mass-assignable' do
+      model = define_model(:example, :blacklisted => :string) do
+        attr_protected :blacklisted
+      end.new
+
+      model.should_not allow_mass_assignment_of(:blacklisted)
+    end
+  end
+
+  context 'an attribute that is not whitelisted for mass-assignment' do
+    it 'rejects being mass-assignable' do
+      model = define_model(:example, :not_whitelisted => :string,
+        :whitelisted => :string) do
+        attr_accessible :whitelisted
+      end.new
+
+      model.should_not allow_mass_assignment_of(:not_whitelisted)
+    end
+  end
+
+  context 'an attribute that is whitelisted for mass-assignment' do
+    it 'accepts being mass-assignable' do
+      define_model(:example, :whitelisted => :string) do
+        attr_accessible :whitelisted
+      end.new.should allow_mass_assignment_of(:whitelisted)
+    end
+  end
+
+  context 'an attribute not included in the mass-assignment blacklist' do
+    it 'accepts being mass-assignable' do
+      model = define_model(:example, :not_blacklisted => :string,
+        :blacklisted => :string) do
+        attr_protected :blacklisted
+      end.new
+
+      model.should allow_mass_assignment_of(:not_blacklisted)
+    end
+  end
+
+  unless active_model_3_2?
+    context 'an attribute on a class with no protected attributes' do
+      it 'accepts being mass-assignable' do
+        no_protected_attributes.should allow_mass_assignment_of(:attr)
+      end
+
+      it 'assigns a negative failure message' do
+        matcher = allow_mass_assignment_of(:attr)
+
+        matcher.matches?(no_protected_attributes).should be_true
+
+        matcher.failure_message_for_should_not.should_not be_nil
+      end
+    end
+
+    def no_protected_attributes
+      define_model(:example, :attr => :string).new
+    end
+  end
+
+  context 'an attribute on a class with all protected attributes' do
+    it 'rejects being mass-assignable' do
+      all_protected_attributes.should_not allow_mass_assignment_of(:attr)
+    end
+
+    def all_protected_attributes
+      define_model(:example, :attr => :string) do
+        attr_accessible nil
+      end.new
+    end
+  end
+
+  if active_model_3_1?
+    context 'an attribute included in the mass-assignment whitelist for admin role only' do
+      it 'rejects being mass-assignable' do
+        mass_assignable_as_admin.should_not allow_mass_assignment_of(:attr)
+      end
+
+      it 'accepts being mass-assignable for admin' do
+        mass_assignable_as_admin.should allow_mass_assignment_of(:attr).as(:admin)
+      end
+
+      def mass_assignable_as_admin
+        define_model(:example, :attr => :string) do
+          attr_accessible :attr, :as => :admin
+        end.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
+  context "#description" do
+    it 'describes itself with multiple values' do
+      matcher = allow_value('foo', 'bar').for(:baz)
+
+      matcher.description.should == '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 == '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 ==
+          %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)
+    end
+
+    it 'rejects a bad value' do
+      validating_format(:with => /abc/).should_not allow_value('xyz').for(:attr)
+    end
+
+    it 'allows several good values' do
+      validating_format(:with => /abc/).
+        should 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)
+    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/)
+    end
+
+    it 'rejects a bad value' do
+      validating_format(:with => /abc/, :message => 'bad value').
+        should_not allow_value('xyz').for(:attr).with_message(/bad/)
+    end
+  end
+
+  context 'an attribute with several validations' do
+    let(:model) 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
+      end.new
+    end
+    bad_values = [nil, '', 'abc', '0', '50001', '123456', []]
+
+    it 'allows a good value' do
+      model.should 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)
+      end
+    end
+
+    it "rejects several bad values (#{bad_values.map(&:inspect).join(', ')})" do
+      model.should_not allow_value(*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
+      matcher = described_class.new('foo').for(:attr)
+      matcher.description
+
+      expect { matcher.matches?(model) }.not_to raise_error(NoMethodError)
+    end
+  end
+
+  context 'with no values' do
+    it 'raises an error' do
+      expect { allow_value.for(:baz) }.
+        to raise_error(ArgumentError, /at least one argument/)
+    end
+  end
+
+  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
+      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
+      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.failure_message_for_should_not.should == 'Expected exception to include /abc/ ' +
+          'when attr is set to "xyz", got Attr is invalid'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
+  it 'does not allow any types' do
+    matcher('abcde').allowed_types.should == ''
+  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)
+    end
+
+    it 'matches if the value is not allowed' do
+      validating_format(:with => /abc/).should matcher('xyz').for(:attr)
+    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')
+    end
+
+    it "delegates its failure message to its allow matcher's negative failure message" do
+      allow_matcher = stub_everything(:failure_message_for_should_not => '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.failure_message_for_should.should == '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')
+    end
+  end
+
+  def matcher(value)
+    described_class.new(value)
+  end
+end

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

@@ -0,0 +1,74 @@
+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)
+    end
+
+    it 'rejects ensuring excluded value' do
+      validating_exclusion(:in => 2..5).
+        should_not 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)
+    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/)
+    end
+  end
+
+  context 'an attribute with custom range validations' do
+    it 'accepts ensuring the correct range and messages' do
+      model = custom_validation do
+        if attr >= 2 && attr <= 5
+          errors.add(:attr, 'should be out of this range')
+        end
+      end
+
+      model.should 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))
+    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))
+    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))
+    end
+
+    it 'has correct description' do
+      ensure_exclusion_of(:attr).in_array([true, 'dog']).description.
+        should == 'ensure exclusion of attr in [true, "dog"]'
+    end
+
+    def validating_exclusion(options)
+      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
+      validates_exclusion_of :attr, options
+    end.new
+  end
+end

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

@@ -0,0 +1,171 @@
+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))
+    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])
+    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
+
+      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
+    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)
+    end
+
+    it 'rejects ensuring a lower minimum value' do
+      validating_inclusion(:in => 2..5).
+        should_not 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)
+    end
+
+    it 'rejects ensuring a lower maximum value' do
+      validating_inclusion(:in => 2..5).
+        should_not 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)
+    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)
+    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/)
+    end
+  end
+
+  context 'an attribute with custom range validations' do
+    it 'accepts ensuring the correct range and messages' do
+      model = custom_validation do
+        if attr < 2
+          errors.add(:attr, 'too low')
+        elsif attr > 5
+          errors.add(:attr, 'too high')
+        end
+      end
+
+      model.should 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))
+    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))
+    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))
+    end
+
+    it 'has correct description' do
+      ensure_inclusion_of(:attr).in_array([true, "dog"]).description.
+        should == '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)
+    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)
+    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)
+    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)
+    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
+    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)
+    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
+    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)
+    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)
+    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
+      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
+      end
+    end
+  end
+end
+
+def validating_inclusion(options)
+  define_model(:example, :attr => :string) do
+    validates_inclusion_of :attr, options
+  end.new
+end