shoulda-matchers 1.4.2 → 1.5.0

data/spec/shoulda/active_model/allow_mass_assignment_of_matcher_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
-  describe "#description" do
-    context 'without a role' do
-      it 'includes the attribute name' do
-        matcher = Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher.new(:attr)
-        matcher.description.should 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
-          matcher = Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher.new(:attr).as(:admin)
-          matcher.description.should eq("allow mass assignment of attr as admin")
-        end
-      end
-    end
-  end
-
-  context "an attribute that is blacklisted from mass-assignment" do
-    let(:model) do
-      define_model(:example, :attr => :string) do
-        attr_protected :attr
-      end.new
-    end
-
-    it "should reject being mass-assignable" do
-      model.should_not allow_mass_assignment_of(:attr)
-    end
-  end
-
-  context "an attribute that is not whitelisted for mass-assignment" do
-    let(:model) do
-      define_model(:example, :attr => :string, :other => :string) do
-        attr_accessible :other
-      end.new
-    end
-
-    it "should reject being mass-assignable" do
-      model.should_not allow_mass_assignment_of(:attr)
-    end
-  end
-
-  context "an attribute that is whitelisted for mass-assignment" do
-    let(:model) do
-      define_model(:example, :attr => :string) do
-        attr_accessible :attr
-      end.new
-    end
-
-    it "should accept being mass-assignable" do
-      model.should allow_mass_assignment_of(:attr)
-    end
-  end
-
-  context "an attribute not included in the mass-assignment blacklist" do
-    let(:model) do
-      define_model(:example, :attr => :string, :other => :string) do
-        attr_protected :other
-      end.new
-    end
-
-    it "should accept being mass-assignable" do
-      model.should allow_mass_assignment_of(:attr)
-    end
-  end
-
-  unless active_model_3_2?
-    context "an attribute on a class with no protected attributes" do
-      let(:model) { define_model(:example, :attr => :string).new }
-
-      it "should accept being mass-assignable" do
-        model.should allow_mass_assignment_of(:attr)
-      end
-
-      it "should assign a negative failure message" do
-        matcher = allow_mass_assignment_of(:attr)
-        matcher.matches?(model).should == true
-        matcher.negative_failure_message.should_not be_nil
-      end
-    end
-  end
-
-  context "an attribute on a class with all protected attributes" do
-    let(:model) do
-      define_model(:example, :attr => :string) do
-        attr_accessible
-      end.new
-    end
-
-    it "should reject being mass-assignable" do
-      model.should_not allow_mass_assignment_of(:attr)
-    end
-  end
-
-  if active_model_3_1?
-    context "an attribute included in the mass-assignment whitelist for admin role only" do
-      let(:model) do
-        define_model(:example, :attr => :string) do
-          attr_accessible :attr, :as => :admin
-        end.new
-      end
-
-      it "should reject being mass-assignable" do
-        model.should_not allow_mass_assignment_of(:attr)
-      end
-
-      it "should accept being mass-assignable for admin" do
-        model.should allow_mass_assignment_of(:attr).as(:admin)
-      end
-    end
-  end
-end

data/spec/shoulda/active_model/allow_value_matcher_spec.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
-  context "an attribute with a format validation" do
-    let(:model) do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/
-      end.new
-    end
-
-    it "allows a good value" do
-      model.should allow_value("abcde").for(:attr)
-    end
-
-    it "rejects a bad value" do
-      model.should_not allow_value("xyz").for(:attr)
-    end
-
-    it "allows several good values" do
-      model.should allow_value("abcde", "deabc").for(:attr)
-    end
-
-    it "rejects several bad values" do
-      model.should_not allow_value("xyz", "zyx", nil, []).for(:attr)
-    end
-  end
-
-  context "an attribute with a format validation and a custom message" do
-    let(:model) do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/, :message => 'bad value'
-      end.new
-    end
-
-    it "allows a good value" do
-      model.should allow_value('abcde').for(:attr).with_message(/bad/)
-    end
-
-    it "rejects a bad value" do
-      model.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 bad values (#{bad_values.map(&:inspect).join(', ')})" do
-      model.should_not allow_value(*bad_values).for(:attr)
-    end
-  end
-
-  context "an AllowValueMatcher with multiple values" do
-    it "should describe itself" do
-      matcher = allow_value("foo", "bar").for(:baz)
-      matcher.description.should == 'allow baz to be set to any of ["foo", "bar"]'
-    end
-  end
-
-  context "an AllowValueMatcher with a single value" do
-    it "should describe itself" do
-      matcher = allow_value("foo").for(:baz)
-      matcher.description.should eq('allow baz to be set to "foo"')
-    end
-
-    it "allows you to call description before calling matches?" do
-      model = define_model(:example, :attr => :string).new
-      matcher = Shoulda::Matchers::ActiveModel::AllowValueMatcher.new("foo").for(:attr)
-      matcher.description
-
-      expect { matcher.matches?(model) }.not_to raise_error
-    end
-  end
-
-  context "an AllowValueMatcher with no values" do
-    it "raises an error" do
-      lambda do
-        allow_value.for(:baz)
-      end.should raise_error(ArgumentError, /at least one argument/)
-    end
-  end
-
-  if Rails::VERSION::STRING.to_f >= 3.2
-    context "an attribute with a strict format validation" do
-      let(:model) do
-        define_model :example, :attr => :string do
-          validates_format_of :attr, :with => /abc/, :strict => true
-        end.new
-      end
-
-      it "strictly rejects a bad value" do
-        model.should_not allow_value("xyz").for(:attr).strict
-      end
-
-      it "strictly allows a bad value with a different message" do
-        model.should allow_value("xyz").for(:attr).with_message(/abc/).strict
-      end
-
-      it "describes itself" do
-        allow_value("xyz").for(:attr).strict.description.
-          should == %{doesn't raise when attr is set to "xyz"}
-      end
-
-      it "provides a useful negative failure message" do
-        matcher = allow_value("xyz").for(:attr).strict.with_message(/abc/)
-        matcher.matches?(model)
-        matcher.negative_failure_message.
-          should == 'Expected exception to include /abc/ ' +
-            'when attr is set to "xyz", got Attr is invalid'
-      end
-    end
-  end
-
-end

data/spec/shoulda/active_model/disallow_value_matcher_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
-  it "does not allow any types" do
-    matcher = Shoulda::Matchers::ActiveModel::DisallowValueMatcher.new("abcde")
-    matcher.allowed_types.should == ""
-  end
-
-  context "an attribute with a format validation" do
-    before do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/
-      end
-      @model = Example.new
-    end
-
-    it "does not match if the value is allowed" do
-      matcher = new_matcher("abcde")
-      matcher.for(:attr)
-      matcher.matches?(@model).should be_false
-    end
-
-    it "matches if the value is not allowed" do
-      matcher = new_matcher("xyz")
-      matcher.for(:attr)
-      matcher.matches?(@model).should be_true
-    end
-  end
-
-  context "an attribute with a format validation and a custom message" do
-    before do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /abc/, :message => 'good message'
-      end
-      @model = Example.new
-    end
-
-    it "does not match if the value and message are both correct" do
-      matcher = new_matcher("abcde")
-      matcher.for(:attr).with_message('good message')
-      matcher.matches?(@model).should be_false
-    end
-
-    it "delegates its failure message to its allow matcher's negative failure message" do
-      allow_matcher = stub_everything(:negative_failure_message => "allow matcher failure")
-      Shoulda::Matchers::ActiveModel::AllowValueMatcher.stubs(:new).returns(allow_matcher)
-
-      matcher = new_matcher("abcde")
-      matcher.for(:attr).with_message('good message')
-      matcher.matches?(@model)
-
-      matcher.failure_message.should == "allow matcher failure"
-    end
-
-    it "matches if the message is correct but the value is not" do
-      matcher = new_matcher("xyz")
-      matcher.for(:attr).with_message('good message')
-      matcher.matches?(@model).should be_true
-    end
-  end
-
-  def new_matcher(value)
-    matcher = Shoulda::Matchers::ActiveModel::DisallowValueMatcher.new(value)
-  end
-end

data/spec/shoulda/active_model/ensure_exclusion_of_matcher_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
-
-  context "an attribute which must be excluded of a range" do
-    before do
-      @model = define_model(:example, :attr => :integer) do
-        validates_exclusion_of :attr, :in => 2..5
-      end.new
-    end
-
-    it "should accept ensuring the correct range" do
-      @model.should ensure_exclusion_of(:attr).in_range(2..5)
-    end
-
-    it "should reject ensuring excluded value" do
-      @model.should_not ensure_exclusion_of(:attr).in_range(2..6)
-    end
-
-    it "should not override the default message with a blank" do
-      @model.should ensure_exclusion_of(:attr).in_range(2..5).with_message(nil)
-    end
-  end
-
-  context "an attribute with a custom ranged value validation" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_exclusion_of :attr, :in => 2..4, :message => 'not good'
-
-      end.new
-    end
-
-    it "should accept ensuring the correct range" do
-      @model.should ensure_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
-    end
-  end
-
-  context "an attribute with custom range validations" do
-    before do
-      define_model :example, :attr => :integer do
-        validate :custom_validation
-        def custom_validation
-          if attr >= 2 && attr <= 5
-            errors.add(:attr, 'shoud be out of this range')
-          end
-        end
-      end
-      @model = Example.new
-    end
-
-    it "should accept ensuring the correct range and messages" do
-      @model.should ensure_exclusion_of(:attr).in_range(2..5).with_message(/shoud be out of this range/)
-    end
-  end
-
-  context "an attribute which must be excluded in an array" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_exclusion_of :attr, :in => %w(one two)
-      end.new
-    end
-
-    it "accepts with correct array" do
-      @model.should ensure_exclusion_of(:attr).in_array(%w(one two))
-    end
-
-    it "rejects when only part of array matches" do
-      @model.should_not ensure_exclusion_of(:attr).in_array(%w(one wrong_value))
-    end
-
-    it "rejects when array doesn't match at all" do
-      @model.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
-  end
-end

data/spec/shoulda/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
-  context "with no validations" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-      end.new
-    end
-
-    it "should reject an array which does not have a validator defined" do
-      @model.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
-      model = define_model(:example, :attr => :string).new
-
-      model.should_not ensure_inclusion_of(:attr).in_array([true, false])
-    end
-  end
-
-  context "where we cannot determine a value outside the array" do
-    it "should raise a custom exception" do
-      model = define_model(:example, :attr => :string).new
-
-      arbitrary_string = Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher::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
-    before do
-      @model = define_model(:example, :attr => :integer) do
-        validates_inclusion_of :attr, :in => 2..5
-      end.new
-    end
-
-    it "should accept ensuring the correct range" do
-      @model.should ensure_inclusion_of(:attr).in_range(2..5)
-    end
-
-    it "should reject ensuring a lower minimum value" do
-      @model.should_not ensure_inclusion_of(:attr).in_range(1..5)
-    end
-
-    it "should reject ensuring a higher minimum value" do
-      @model.should_not ensure_inclusion_of(:attr).in_range(3..5)
-    end
-
-    it "should reject ensuring a lower maximum value" do
-      @model.should_not ensure_inclusion_of(:attr).in_range(2..4)
-    end
-
-    it "should reject ensuring a higher maximum value" do
-      @model.should_not ensure_inclusion_of(:attr).in_range(2..6)
-    end
-
-    it "should not override the default message with a blank" do
-      @model.should ensure_inclusion_of(:attr).in_range(2..5).with_message(nil)
-    end
-  end
-
-  context "an attribute with a custom ranged value validation" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_inclusion_of :attr, :in => 2..4, :message => 'not good'
-
-      end.new
-    end
-
-    it "should accept ensuring the correct range" do
-      @model.should ensure_inclusion_of(:attr).in_range(2..4).with_message(/not good/)
-    end
-  end
-
-  context "an attribute with custom range validations" do
-    before do
-      define_model :example, :attr => :integer do
-        validate :custom_validation
-        def custom_validation
-          if attr < 2
-            errors.add(:attr, 'too low')
-          elsif attr > 5
-            errors.add(:attr, 'too high')
-          end
-        end
-      end
-      @model = Example.new
-    end
-
-    it "should accept ensuring the correct range and messages" do
-      @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
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_inclusion_of :attr, :in => %w(one two)
-      end.new
-    end
-
-    it "accepts with correct array" do
-      @model.should ensure_inclusion_of(:attr).in_array(%w(one two))
-    end
-
-    it "rejects when only part of array matches" do
-      @model.should_not ensure_inclusion_of(:attr).in_array(%w(one wrong_value))
-    end
-
-    it "rejects when array doesn't match at all" do
-      @model.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
-      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(true)
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(false)
-    end
-
-    it "rejects allow_nil" do
-      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(true)
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(false)
-    end
-  end
-
-  context "allowed blank and allowed nil" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-          validates_inclusion_of :attr, :in => %w(one two), :allow_blank => true, :allow_nil => true
-      end.new
-    end
-
-    it "allows allow_blank" do
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(true)
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank()
-      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_blank(false)
-    end
-
-    it "allows allow_nil" do
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(true)
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil()
-      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(false)
-    end
-  end
-
-  context "an attribute allowing some blank values but not others" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_inclusion_of :attr, :in => ['one', 'two', '']
-      end.new
-    end
-
-    it "rejects allow_blank" do
-      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(true)
-      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(false)
-    end
-  end
-
-  if Rails::VERSION::STRING.to_f >= 3.2
-    context "a strict attribute which must be included in a range" do
-      before do
-        @model = define_model(:example, :attr => :integer) do
-          validates_inclusion_of :attr, :in => 2..5, :strict => true
-        end.new
-      end
-
-      it "should accept ensuring the correct range" do
-        @model.should ensure_inclusion_of(:attr).in_range(2..5).strict
-      end
-
-      it "should not accept ensuring another range" do
-        @model.should_not ensure_inclusion_of(:attr).in_range(2..6).strict
-      end
-    end
-  end
-end