shoulda-matchers 1.0.0 → 1.1.0

data/spec/shoulda/active_model/allow_mass_assignment_of_matcher_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
+  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
+
+  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
+
+  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 ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 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

@@ -0,0 +1,91 @@
+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
+  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
+end

data/spec/shoulda/active_model/ensure_exclusion_of_matcher_spec.rb

@@ -0,0 +1,57 @@
+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
+
+end

data/spec/shoulda/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
+
+  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
+
+end

data/spec/shoulda/active_model/ensure_length_of_matcher_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
+
+  context "an attribute with a non-zero minimum length validation" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 4
+      end.new
+    end
+
+    it "should accept ensuring the correct minimum length" do
+      @model.should ensure_length_of(:attr).is_at_least(4)
+    end
+
+    it "should reject ensuring a lower minimum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_at_least(3).with_short_message(/.*/)
+    end
+
+    it "should reject ensuring a higher minimum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_at_least(5).with_short_message(/.*/)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should ensure_length_of(:attr).is_at_least(4).with_short_message(nil)
+    end
+  end
+
+  context "an attribute with a minimum length validation of 0" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 0
+      end.new
+    end
+
+    it "should accept ensuring the correct minimum length" do
+      @model.should ensure_length_of(:attr).is_at_least(0)
+    end
+  end
+
+  context "an attribute with a maximum length" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :maximum => 4
+      end.new
+    end
+
+    it "should accept ensuring the correct maximum length" do
+      @model.should ensure_length_of(:attr).is_at_most(4)
+    end
+
+    it "should reject ensuring a lower maximum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_at_most(3).with_long_message(/.*/)
+    end
+
+    it "should reject ensuring a higher maximum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_at_most(5).with_long_message(/.*/)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should ensure_length_of(:attr).is_at_most(4).with_long_message(nil)
+    end
+  end
+
+  context "an attribute with a required exact length" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :is => 4
+      end.new
+    end
+
+    it "should accept ensuring the correct length" do
+      @model.should ensure_length_of(:attr).is_equal_to(4)
+    end
+
+    it "should reject ensuring a lower maximum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_equal_to(3).with_message(/.*/)
+    end
+
+    it "should reject ensuring a higher maximum length with any message" do
+      @model.should_not ensure_length_of(:attr).is_equal_to(5).with_message(/.*/)
+    end
+
+    it "should not override the default message with a blank" do
+      @model.should ensure_length_of(:attr).is_equal_to(4).with_message(nil)
+    end
+  end
+
+  context "an attribute with a custom minimum length validation" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :minimum => 4, :too_short => 'short'
+      end.new
+    end
+
+    it "should accept ensuring the correct minimum length" do
+      @model.should ensure_length_of(:attr).is_at_least(4).with_short_message(/short/)
+    end
+
+  end
+
+  context "an attribute with a custom maximum length validation" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_length_of :attr, :maximum => 4, :too_long => 'long'
+      end.new
+    end
+
+    it "should accept ensuring the correct minimum length" do
+      @model.should ensure_length_of(:attr).is_at_most(4).with_long_message(/long/)
+    end
+
+  end
+
+  context "an attribute without a length validation" do
+    before do
+      @model = define_model(:example, :attr => :string).new
+    end
+
+    it "should reject ensuring a minimum length" do
+      @model.should_not ensure_length_of(:attr).is_at_least(1)
+    end
+  end
+
+end

data/spec/shoulda/active_model/helpers_spec.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+require "spec_helper"
+
+def store_translations(options = {:without => []})
+  options[:without] = Array.wrap(options[:without] || [])
+
+  translations = {
+    :activerecord => {
+      :errors => {
+        :models => {
+          :example => {
+              :attributes => {
+              :attr => {}
+            }
+          }
+        },
+        :messages => {}
+      }
+    },
+    :errors => {
+      :attributes => {
+        :attr => {}
+      },
+      :messages => {}
+    }
+  }
+
+  unless options[:without].include?(:model_attribute)
+    translations[:activerecord][:errors][:models][:example][:attributes][:attr][:blank] = 'Don’t you do that to me!'
+  end
+
+  unless options[:without].include?(:model)
+    translations[:activerecord][:errors][:models][:example][:blank] = 'Give it one more try!'
+  end
+
+  unless options[:without].include?(:message)
+    translations[:activerecord][:errors][:messages][:blank] = 'Oh no!'
+  end
+
+  unless options[:without].include?(:attribute)
+    translations[:errors][:attributes][:attr][:blank] = 'Seriously?'
+  end
+
+  I18n.backend.store_translations(:en, translations)
+end
+
+describe Shoulda::Matchers::ActiveModel::Helpers do
+  include Shoulda::Matchers::ActiveModel
+
+  describe "default_error_message" do
+    before do
+      define_model :example, :attr => :string do
+        validates_presence_of :attr
+      end
+      @model = Example.new
+    end
+
+    after { I18n.backend.reload! }
+
+    context "if the translation for the model attribute’s error exists" do
+      it "provides the right error message" do
+        store_translations
+        @model.should validate_presence_of(:attr)
+      end
+    end
+
+    context "if no translation for the model attribute’s error exists" do
+      context "and the translation for the model’s error exists" do
+        it "provides the right error message" do
+          store_translations(:without => :model_attribute)
+          @model.should validate_presence_of(:attr)
+        end
+      end
+
+      context "and no translation for the model’s error exists" do
+        context "and the translation for the message exists" do
+          it "provides the right error message" do
+            store_translations(:without => [:model_attribute, :model])
+            @model.should validate_presence_of(:attr)
+          end
+        end
+
+        context "and no translation for the message exists" do
+          context "and the translation for the attribute exists" do
+            it "provides the right error message" do
+              store_translations(:without => [:model_attribute, :model, :message])
+              @model.should validate_presence_of(:attr)
+            end
+          end
+
+          context "and no translation for the attribute exists" do
+            it "provides the general error message" do
+              @model.should validate_presence_of(:attr)
+            end
+          end
+        end
+      end
+    end
+  end
+end