shoulda-matchers 1.4.2 → 1.5.0

data/spec/shoulda/active_model/ensure_length_of_matcher_spec.rb

@@ -1,138 +0,0 @@
-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 required exact length and another validation" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :is => 4
-        validates_numericality_of :attr
-      end.new
-    end
-
-    it "should accept ensuring the correct length" do
-      @model.should ensure_length_of(:attr).is_equal_to(4)
-    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

@@ -1,129 +0,0 @@
-# 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!"
-    translations[:activerecord][:errors][:models][:example][:attributes][:attr][:wrong_length] = "Don't you do that to me!"
-  end
-
-  unless options[:without].include?(:model)
-    translations[:activerecord][:errors][:models][:example][:blank] = 'Give it one more try!'
-    translations[:activerecord][:errors][:models][:example][:wrong_length] = 'Give it one more try!'
-  end
-
-  unless options[:without].include?(:message)
-    translations[:activerecord][:errors][:messages][:blank] = 'Oh no!'
-    translations[:activerecord][:errors][:messages][:wrong_length] = 'Oh no!'
-  end
-
-  unless options[:without].include?(:attribute)
-    translations[:errors][:attributes][:attr][:blank] = 'Seriously?'
-    translations[:errors][:attributes][:attr][:wrong_length] = '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
-        validates_length_of :attr, :is => 40, :allow_blank => true
-      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 for validate_presence_of" do
-        store_translations
-        @model.should validate_presence_of(:attr)
-      end
-
-      it "provides the right error message for validates_length_of" do
-        store_translations
-        @model.should ensure_length_of(:attr).is_equal_to(40)
-      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 for validate_presence_of" do
-          store_translations(:without => :model_attribute)
-          @model.should validate_presence_of(:attr)
-        end
-
-        it "provides the right error message for validates_length_of" do
-          store_translations(:without => :model_attribute)
-          @model.should ensure_length_of(:attr).is_equal_to(40)
-        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 for validate_presence_of" do
-            store_translations(:without => [:model_attribute, :model])
-            @model.should validate_presence_of(:attr)
-          end
-
-          it "provides the right error message for validates_length_of" do
-            store_translations(:without => [:model_attribute, :model])
-            @model.should ensure_length_of(:attr).is_equal_to(40)
-          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 for validate_presence_of" do
-              store_translations(:without => [:model_attribute, :model, :message])
-              @model.should validate_presence_of(:attr)
-            end
-
-            it "provides the right error message for validates_length_of" do
-              store_translations(:without => [:model_attribute, :model, :message])
-              @model.should ensure_length_of(:attr).is_equal_to(40)
-            end
-          end
-
-          context "and no translation for the attribute exists" do
-            it "provides the general error message for validate_presence_of" do
-              @model.should validate_presence_of(:attr)
-            end
-
-            it "provides the general error message for validates_length_of" do
-              @model.should ensure_length_of(:attr).is_equal_to(40)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/shoulda/active_model/only_integer_matcher_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
-  context "given an attribute that only allows integer values" do
-    before do
-      define_model :example, :attr => :string do
-        validates_numericality_of :attr, { :only_integer => true }
-      end
-      @model = Example.new
-    end
-
-    it "matches" do
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model).should be_true
-    end
-
-    it "allows integer types" do
-      matcher = new_matcher(:attr)
-      matcher.allowed_types.should == "integer"
-    end
-
-    it "returns itself when given a message" do
-      matcher = new_matcher(:attr)
-      matcher.with_message("some message").should == matcher
-    end
-  end
-
-  context "given an attribute that only allows integer values with a custom validation message" do
-    before do
-      define_model :example, :attr => :string do
-        validates_numericality_of :attr, { :only_integer => true, :message => 'custom' }
-      end
-      @model = Example.new
-    end
-
-    it "should only allow integer values for that attribute with that message" do
-      matcher = new_matcher(:attr)
-      matcher.with_message(/custom/)
-      matcher.matches?(@model).should be_true
-    end
-
-    it "should not allow integer values for that attribute with another message" do
-      matcher = new_matcher(:attr)
-      matcher.with_message(/wrong/)
-      matcher.matches?(@model).should be_false
-    end
-  end
-
-  context "given an attribute that allows values other than integers" do
-    before do
-      @model = define_model(:example, :attr => :string).new
-    end
-
-    it "does not match" do
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model).should be_false
-    end
-
-    it "should fail with the ActiveRecord :not_an_integer message" do
-      matcher = new_matcher(:attr)
-      matcher.matches?(@model)
-      matcher.failure_message.should include 'Expected errors to include "must be an integer"'
-    end
-  end
-
-  def new_matcher(attribute)
-    matcher = Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher.new(attribute)
-  end
-end

data/spec/shoulda/active_model/validate_acceptance_of_matcher_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher do
-
-  context "an attribute which must be accepted" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_acceptance_of :attr
-      end.new
-    end
-
-    it "should require that attribute to be accepted" do
-      @model.should validate_acceptance_of(:attr)
-    end
-
-    it "should not overwrite the default message with nil" do
-      @model.should validate_acceptance_of(:attr).with_message(nil)
-    end
-  end
-
-  context "an attribute that does not need to be accepted" do
-    before do
-      @model = define_model(:example, :attr => :string).new
-    end
-
-    it "should not require that attribute to be accepted" do
-      @model.should_not validate_acceptance_of(:attr)
-    end
-  end
-
-  context "an attribute which must be accepted with a custom message" do
-    before do
-      @model = define_model(:example, :attr => :string) do
-        validates_acceptance_of :attr, :message => 'custom'
-      end.new
-    end
-
-    it "should require that attribute to be accepted with that message" do
-      @model.should validate_acceptance_of(:attr).with_message(/custom/)
-    end
-  end
-
-end

data/spec/shoulda/active_model/validate_confirmation_of_matcher_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
-
-  context "an attribute which needs confirmation" do
-    before do
-      define_model(:example, :attr => :string) do
-        validates_confirmation_of :attr
-      end
-      @model = Example.new
-    end
-
-    it "should require confirmation of that attribute" do
-      @model.should validate_confirmation_of(:attr)
-    end
-
-    it "should not override the default message with a blank" do
-      @model.should validate_confirmation_of(:attr).with_message(nil)
-    end
-  end
-
-  context "an attribute which must be confirmed with a custom message" do
-    before do
-      define_model :example, :attr => :string do
-        validates_confirmation_of :attr, :message => 'custom'
-      end
-      @model = Example.new
-    end
-
-    it "should require confirmation of that attribute with that message" do
-      @model.should validate_confirmation_of(:attr).with_message(/custom/)
-    end
-
-    it "should not require confirmation of that attribute with another message" do
-      @model.should_not validate_confirmation_of(:attr)
-    end
-  end
-
-  context "an attribute which doesn't need confirmation" do
-    before do
-      @model = define_model(:example, :attr => :string).new
-    end
-
-    it "should not require confirmation of that attribute" do
-      @model.should_not validate_confirmation_of(:attr)
-    end
-  end
-end

data/spec/shoulda/active_model/validate_format_of_matcher_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateFormatOfMatcher do
-  context "a postal code" do
-    before do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /^\d{5}$/
-      end
-      @model = Example.new
-    end
-
-    it "is valid" do
-      @model.should validate_format_of(:attr).with('12345')
-    end
-
-    it "is not valid with blank" do
-      @model.should_not validate_format_of(:attr).with(' ')
-      @model.should validate_format_of(:attr).not_with(' ')
-    end
-
-    it "is not valid with nil" do
-      @model.should_not validate_format_of(:attr).with(nil)
-    end
-
-    it "is not valid with alpha in zip" do
-      @model.should_not validate_format_of(:attr).with('1234a')
-      @model.should validate_format_of(:attr).not_with('1234a')
-    end
-
-    it "is not valid with too few digits" do
-      @model.should_not validate_format_of(:attr).with('1234')
-      @model.should validate_format_of(:attr).not_with('1234')
-    end
-
-    it "is not valid with too many digits" do
-      @model.should_not validate_format_of(:attr).with('123456')
-      @model.should validate_format_of(:attr).not_with('123456')
-    end
-
-    it "raises error if you try to call both with and not_with" do
-      expect { validate_format_of(:attr).not_with('123456').with('12345') }.
-        to raise_error(RuntimeError)
-    end
-  end
-
-  context "when allow_blank and allow_nil are set" do
-    before do
-      define_model :example, :attr => :string do
-        validates_format_of :attr, :with => /^\d{5}$/, :allow_blank => true, :allow_nil => true
-      end
-      @model = Example.new
-    end
-
-    it "is valid when attr is nil" do
-      @model.should validate_format_of(:attr).with(nil)
-    end
-
-    it "is valid when attr is blank" do
-      @model.should validate_format_of(:attr).with(' ')
-    end
-
-    describe "#allow_blank" do
-      it "allows allow_blank" do
-        @model.should validate_format_of(:attr).allow_blank
-        @model.should validate_format_of(:attr).allow_blank(true)
-        @model.should_not validate_format_of(:attr).allow_blank(false)
-      end
-    end
-
-    describe "#allow_nil" do
-      it "allows allow_nil" do
-        @model.should validate_format_of(:attr).allow_nil
-        @model.should validate_format_of(:attr).allow_nil(true)
-        @model.should_not validate_format_of(:attr).allow_nil(false)
-      end
-    end
-  end
-
-end