mcmire-shoulda-matchers 2.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
+        expect(described_class.new(:attr).description).
+          to eq '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
+          expect(described_class.new(:attr).as(:admin).description).
+            to eq '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
+
+      expect(model).not_to 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
+
+      expect(model).not_to allow_mass_assignment_of(:not_whitelisted)
+    end
+  end
+
+  context 'an attribute that is whitelisted for mass-assignment' do
+    it 'accepts being mass-assignable' do
+      expect(define_model(:example, whitelisted: :string) do
+        attr_accessible :whitelisted
+      end.new).to 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
+
+      expect(model).to allow_mass_assignment_of(:not_blacklisted)
+    end
+  end
+
+  unless active_model_3_2? || active_model_4_0?
+    context 'an attribute on a class with no protected attributes' do
+      it 'accepts being mass-assignable' do
+        expect(no_protected_attributes).to allow_mass_assignment_of(:attr)
+      end
+
+      it 'assigns a negative failure message' do
+        matcher = allow_mass_assignment_of(:attr)
+
+        expect(matcher.matches?(no_protected_attributes)).to eq true
+
+        expect(matcher.failure_message_when_negated).not_to 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
+      expect(all_protected_attributes).not_to 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
+        expect(mass_assignable_as_admin).not_to allow_mass_assignment_of(:attr)
+      end
+
+      it 'accepts being mass-assignable for admin' do
+        expect(mass_assignable_as_admin).to 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,170 @@
+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)
+
+      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)
+
+      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
+
+        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
+      expect(validating_format(with: /abc/)).to allow_value('abcde').for(:attr)
+    end
+
+    it 'rejects a bad value' do
+      expect(validating_format(with: /abc/)).not_to allow_value('xyz').for(:attr)
+    end
+
+    it 'allows several good values' do
+      expect(validating_format(with: /abc/)).
+        to allow_value('abcde', 'deabc').for(:attr)
+    end
+
+    it 'rejects several bad values' do
+      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
+      expect(validating_format(with: /abc/, message: 'bad value')).
+        to allow_value('abcde').for(:attr).with_message(/bad/)
+    end
+
+    it 'rejects a bad value' do
+      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
+      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
+      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
+        validate :custom_validation
+
+        def custom_validation
+          if self[:attr] != 'good value'
+            self.errors[:attr2] << 'some message'
+          end
+        end
+      end.new
+    end
+  end
+
+  context "an attribute with a context-dependent validation" do
+    context "without the validation context" do
+      it "allows a bad value" do
+        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
+        expect(validating_format(with: /abc/, on: :customisable)).to allow_value("abcde").for(:attr).on(:customisable)
+      end
+
+      it "rejects a bad value" do
+        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
+        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
+      expect(model).to allow_value('12345').for(:attr)
+    end
+
+    bad_values.each do |bad_value|
+      it "rejects a bad value (#{bad_value.inspect})" do
+        expect(model).not_to allow_value(bad_value).for(:attr)
+      end
+    end
+
+    it "rejects several bad values (#{bad_values.map(&:inspect).join(', ')})" do
+      expect(model).not_to allow_value(*bad_values).for(:attr)
+    end
+
+    it "rejects a mix of both good and bad values" do
+      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
+      matcher = described_class.new('foo').for(:attr)
+      matcher.description
+
+      expect { matcher.matches?(model) }.not_to raise_error
+    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
+        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
+        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))
+
+        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
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
+  context 'an attribute with a format validation' do
+    it 'does not match if the value is allowed' do
+      expect(validating_format(with: /abc/)).not_to matcher('abcde').for(:attr)
+    end
+
+    it 'matches if the value is not allowed' do
+      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
+        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
+        expect(validating_format(with: /abc/, on: :customisable)).to matcher("xyz").for(:attr).on(:customisable)
+      end
+
+      it "does not match a good value" do
+        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
+      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')
+      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'))
+
+      expect(matcher.failure_message).to eq 'allow matcher failure'
+    end
+
+    it 'matches if the message is correct but the value is not' do
+      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
+      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
+      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
+        validate :custom_validation
+
+        def custom_validation
+          if self[:attr] != 'good value'
+            self.errors[:attr2] << 'some message'
+          end
+        end
+      end.new
+    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,95 @@
+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
+      expect(validating_exclusion(in: 2..5)).
+        to ensure_exclusion_of(:attr).in_range(2..5)
+    end
+
+    it 'rejects ensuring excluded value' do
+      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
+      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
+      expect(validating_exclusion(in: 2...5)).
+        to ensure_exclusion_of(:attr).in_range(2...5)
+    end
+
+    it 'rejects ensuring excluded value' do
+      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
+      expect(validating_exclusion(in: 2..4, message: 'not good')).
+        to 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
+
+      expect(model).to ensure_exclusion_of(:attr).in_range(2..5).
+        with_message(/should be out of this range/)
+
+      model = custom_validation do
+        if attr >= 2 && attr <= 4
+          errors.add(:attr, 'should be out of this range')
+        end
+      end
+
+      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
+      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
+      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
+      expect(validating_exclusion(in: %w(one two))).
+        not_to ensure_exclusion_of(:attr).in_array(%w(cat dog))
+    end
+
+    it 'has correct description' do
+      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
+        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