mcmire-shoulda-matchers 2.5.0

data/spec/shoulda/matchers/active_model/numericality_matchers/even_number_matcher_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher  do
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows even number' do
+    expect(subject.allowed_type).to eq 'even numbers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 2 }
+  end
+
+  context 'when the model has an even validation' do
+    it 'matches' do
+      match = subject
+      expect(validating_even_number).to match
+    end
+  end
+
+  context 'when the model does not have an even validation' do
+    it 'does not match' do
+      match = subject
+      expect(not_validating_even_number).not_to match
+    end
+
+    it 'fails with the ActiveRecord :even message' do
+      match = subject
+      expect {
+        expect(not_validating_even_number).to match
+      }.to fail_with_message_including('Expected errors to include "must be even"')
+    end
+  end
+
+  context 'with custom validation message' do
+    it 'only accepts even number values for that attribute with that message' do
+      expect(validating_even_number(message: 'custom')).to subject.with_message(/custom/)
+    end
+
+    it 'fails even number values for that attribute with another message' do
+      expect(validating_even_number(message: 'custom')).not_to subject.with_message(/wrong/)
+    end
+  end
+
+
+  def validating_even_number(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { even: true }.merge(options)
+    end.new
+  end
+
+  def not_validating_even_number
+    define_model(:example, attr: :string).new
+  end
+
+end

data/spec/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher  do
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows odd number' do
+    expect(subject.allowed_type).to eq 'odd numbers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 2 }
+  end
+
+  context 'when the model has an odd validation' do
+    it 'matches' do
+      match = subject
+      expect(validating_odd_number).to match
+    end
+  end
+
+  context 'when the model does not have an odd validation' do
+    it 'does not match' do
+      match = subject
+      expect(not_validating_odd_number).not_to match
+    end
+
+    it 'fails with the ActiveRecord :odd message' do
+      match = subject
+      expect {
+        expect(not_validating_odd_number).to match
+      }.to fail_with_message_including('Expected errors to include "must be odd"')
+    end
+  end
+
+  context 'with custom validation message' do
+    it 'only accepts odd number values for that attribute with that message' do
+      expect(validating_odd_number(message: 'custom')).to subject.with_message(/custom/)
+    end
+
+    it 'fails odd number values for that attribute with another message' do
+      expect(validating_odd_number(message: 'custom')).not_to subject.with_message(/wrong/)
+    end
+  end
+
+
+  def validating_odd_number(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { odd: true }.merge(options)
+    end.new
+  end
+
+  def not_validating_odd_number
+    define_model(:example, attr: :string).new
+  end
+
+end

data/spec/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatcher do
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows integer types' do
+    expect(subject.allowed_type).to eq 'integers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 1 }
+  end
+
+  context 'given an attribute that only allows integer values' do
+    it 'matches' do
+      match = subject
+      expect(validating_only_integer).to match
+    end
+  end
+
+  context 'given an attribute that only allows integer values with a custom validation message' do
+    it 'only accepts integer values for that attribute with that message' do
+      expect(validating_only_integer(message: 'custom')).to subject.with_message(/custom/)
+    end
+
+    it 'rejects integer values for that attribute with another message' do
+      expect(validating_only_integer(message: 'custom')).not_to subject.with_message(/wrong/)
+    end
+  end
+
+  context 'when the model does not have an only_integer validation' do
+    it 'does not match' do
+      match = subject
+      expect(not_validating_only_integer).not_to match
+    end
+
+    it 'fails with the ActiveRecord :not_an_integer message' do
+      match = subject
+      expect {
+        expect(not_validating_only_integer).to match
+      }.to fail_with_message_including('Expected errors to include "must be an integer"')
+    end
+  end
+
+  def validating_only_integer(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { only_integer: true }.merge(options)
+    end.new
+  end
+
+  def not_validating_only_integer
+    define_model(:example, attr: :string).new
+  end
+end

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

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
+  if active_model_4_0?
+    context 'a model with an absence validation' do
+      it 'accepts' do
+        expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
+      end
+
+      it 'does not override the default message with a present' do
+        expect(validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
+      end
+    end
+
+    context 'a model without an absence validation' do
+      it 'rejects' do
+        model = define_model(:example, attr: :string).new
+        expect(model).not_to validate_absence_of(:attr)
+      end
+    end
+
+    context 'an ActiveModel class with an absence validation' do
+      it 'accepts' do
+        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr)
+      end
+
+      it 'does not override the default message with a blank' do
+        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
+      end
+    end
+
+    context 'an ActiveModel class without an absence validation' do
+      it 'rejects' do
+        expect(active_model_with(:attr)).not_to validate_absence_of(:attr)
+      end
+
+      it 'provides the correct failure message' do
+        message = %{Expected errors to include "must be blank" when attr is set to "an arbitrary value", got no errors}
+
+        expect { expect(active_model_with(:attr)).to validate_absence_of(:attr) }.to fail_with_message(message)
+      end
+    end
+
+    context 'a has_many association with an absence validation' do
+      it 'requires the attribute to not be set' do
+        expect(having_many(:children, absence: true)).to validate_absence_of(:children)
+      end
+    end
+
+    context 'a has_many association without an absence validation' do
+      it 'does not require the attribute to not be set' do
+        expect(having_many(:children, absence: false)).
+          not_to validate_absence_of(:children)
+      end
+    end
+
+    context 'an absent has_and_belongs_to_many association' do
+      it 'accepts' do
+        model = having_and_belonging_to_many(:children, absence: true)
+        expect(model).to validate_absence_of(:children)
+      end
+    end
+
+    context 'a non-absent has_and_belongs_to_many association' do
+      it 'rejects' do
+        model = having_and_belonging_to_many(:children, absence: false)
+        expect(model).not_to validate_absence_of(:children)
+      end
+    end
+
+    context "an i18n translation containing %{attribute} and %{model}" do
+      after { I18n.backend.reload! }
+
+      it "does not raise an exception" do
+        stub_translation("activerecord.errors.messages.present",
+                         "%{attribute} must be blank in a %{model}")
+
+        expect {
+          expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
+        }.to_not raise_exception
+      end
+    end
+
+    context "an attribute with a context-dependent validation" do
+      context "without the validation context" do
+        it "does not match" do
+          expect(validating_absence_of(:attr, on: :customisable)).not_to validate_absence_of(:attr)
+        end
+      end
+
+      context "with the validation context" do
+        it "matches" do
+          expect(validating_absence_of(:attr, on: :customisable)).to validate_absence_of(:attr).on(:customisable)
+        end
+      end
+    end
+
+    def validating_absence_of(attr, options = {})
+      define_model :example, attr => :string do
+        validates_absence_of attr, options
+      end.new
+    end
+
+    def active_model_with(attr, &block)
+      define_active_model_class('Example', accessors: [attr], &block).new
+    end
+
+    def active_model_validating_absence_of(attr)
+      active_model_with(attr) do
+        validates_absence_of attr
+      end
+    end
+
+    def having_many(plural_name, options = {})
+      define_model plural_name.to_s.singularize
+      define_model :parent do
+        has_many plural_name
+        if options[:absence]
+          validates_absence_of plural_name
+        end
+      end.new
+    end
+
+    def having_and_belonging_to_many(plural_name, options = {})
+      create_table 'children_parents', id: false do |t|
+        t.integer "#{plural_name.to_s.singularize}_id"
+        t.integer :parent_id
+      end
+
+      define_model plural_name.to_s.singularize
+      define_model :parent do
+        has_and_belongs_to_many plural_name
+        if options[:absence]
+          validates_absence_of plural_name
+        end
+      end.new
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher do
+  context 'a model with an acceptance validation' do
+    it 'accepts when the attributes match' do
+      expect(validating_acceptance).to matcher
+    end
+
+    it 'does not overwrite the default message with nil' do
+      expect(validating_acceptance).to matcher.with_message(nil)
+    end
+  end
+
+  context 'a model without an acceptance validation' do
+    it 'rejects' do
+      expect(define_model(:example, attr: :string).new).not_to matcher
+    end
+  end
+
+  context 'an attribute which must be accepted with a custom message' do
+    it 'accepts when the message matches' do
+      expect(validating_acceptance(message: 'custom')).
+        to matcher.with_message(/custom/)
+    end
+
+    it 'rejects when the message does not match' do
+      expect(validating_acceptance(message: 'custom')).
+        not_to matcher.with_message(/wrong/)
+    end
+  end
+
+  def matcher
+    validate_acceptance_of(:attr)
+  end
+
+  def validating_acceptance(options = {})
+    define_model(:example, attr: :string) do
+      validates_acceptance_of :attr, options
+    end.new
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
+  context '#description' do
+    it 'states that the confirmation must match its base attribute' do
+      expect(matcher.description).to eq 'require attr_confirmation to match attr'
+    end
+  end
+
+  context 'a model with a confirmation validation' do
+    it 'accepts' do
+      expect(validating_confirmation).to matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      expect(validating_confirmation).to matcher.with_message(nil)
+    end
+  end
+
+  context 'a model without a confirmation validation' do
+    it 'rejects' do
+      expect(define_model(:example, attr: :string).new).not_to matcher
+    end
+  end
+
+  context 'a confirmation validation with a custom message' do
+    it 'accepts when the message matches' do
+      expect(validating_confirmation(message: 'custom')).
+        to matcher.with_message(/custom/)
+    end
+
+    it 'rejects when the messages do not match' do
+      expect(validating_confirmation(message: 'custom')).
+        not_to matcher.with_message(/wrong/)
+    end
+  end
+
+  def matcher
+    validate_confirmation_of(:attr)
+  end
+
+  def validating_confirmation(options = {})
+    define_model(:example, attr: :string) do
+      validates_confirmation_of :attr, options
+    end.new
+  end
+end

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

@@ -0,0 +1,331 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
+
+  context 'with a model with a numericality validation' do
+    it 'accepts' do
+      expect(validating_numericality).to matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      expect(validating_numericality).to matcher.with_message(nil)
+    end
+  end
+
+  context 'with a model without a numericality validation' do
+    it 'rejects' do
+      expect(not_validating_numericality).not_to matcher
+    end
+
+    it 'rejects with the ActiveRecord :not_a_number message' do
+      the_matcher = matcher
+
+      the_matcher.matches?(define_model(:example, attr: :string).new)
+
+      expect(the_matcher.failure_message_when_negated)
+        .to include 'Did not expect errors to include "is not a number"'
+    end
+
+    it 'rejects with the ActiveRecord :not_an_integer message' do
+      the_matcher = matcher.only_integer
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be an integer"'
+      )
+    end
+
+    it 'rejects with the ActiveRecord :odd message' do
+      the_matcher = matcher.odd
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be odd"'
+      )
+    end
+
+    it 'rejects with the ActiveRecord :even message' do
+      the_matcher = matcher.even
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be even"'
+      )
+    end
+  end
+
+  context 'with the allow_nil option' do
+    it 'allows nil values for that attribute' do
+      expect(validating_numericality(allow_nil: true)).to matcher.allow_nil
+    end
+
+    it 'rejects when the model does not allow nil' do
+      the_matcher = matcher.allow_nil
+      expect {
+        expect(validating_numericality).to the_matcher
+      }.to fail_with_message_including('Did not expect errors to include "is not a number"')
+    end
+  end
+
+  context 'with the only_integer option' do
+    it 'allows integer values for that attribute' do
+      expect(validating_numericality(only_integer: true)).to matcher.only_integer
+    end
+
+    it 'rejects when the model does not enforce integer values' do
+      expect(validating_numericality).not_to matcher.only_integer
+    end
+
+    it 'rejects with the ActiveRecord :not_an_integer message' do
+      the_matcher = matcher.only_integer
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be an integer"'
+      )
+    end
+  end
+
+  context 'with the odd option' do
+    it 'allows odd number values for that attribute' do
+      expect(validating_numericality(odd: true)).to matcher.odd
+    end
+
+    it 'rejects when the model does not enforce odd number values' do
+      expect(validating_numericality).not_to matcher.odd
+    end
+
+    it 'rejects with the ActiveRecord :odd message' do
+      the_matcher = matcher.odd
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be odd"'
+      )
+    end
+  end
+
+  context 'with the even option' do
+    it 'allows even number values for that attribute' do
+      expect(validating_numericality(even: true)).to matcher.even
+    end
+
+    it 'rejects when the model does not enforce even number values' do
+      expect(validating_numericality).not_to matcher.even
+    end
+
+    it 'rejects with the ActiveRecord :even message' do
+      the_matcher = matcher.even
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be even"'
+      )
+    end
+  end
+
+  context 'with multiple options together' do
+    context 'the success cases' do
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 18))
+          .to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 18))
+          .to matcher.even.is_greater_than(18)
+      end
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 99))
+          .to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(
+                 only_integer: true,
+                 greater_than: 18,
+                 less_than: 99)
+        ).to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+    end
+
+    context 'the failure cases with different validators' do
+      it do
+        expect(validating_numericality(even: true, greater_than: 18))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(greater_than: 18))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(
+          validating_numericality(even: true, greater_than_or_equal_to: 18)
+        ).not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, greater_than: 18))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(
+                 odd: true,
+                 greater_than_or_equal_to: 99
+               )
+        ).not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(
+                 only_integer: true,
+                 greater_than_or_equal_to: 18,
+                 less_than: 99
+               )
+        ).not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+    end
+
+    context 'the failure cases with wrong values' do
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 19))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 17))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 20))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 16))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 101))
+         .not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 97))
+          .not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true,
+                                          greater_than: 19,
+                                          less_than: 99))
+          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true,
+                                          greater_than: 18,
+                                          less_than: 100))
+          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+    end
+  end
+
+  context 'with a custom validation message' do
+    it 'accepts when the messages match' do
+      expect(validating_numericality(message: 'custom')).
+          to matcher.with_message(/custom/)
+    end
+
+    it 'rejects when the messages do not match' do
+      expect(validating_numericality(message: 'custom')).
+          not_to matcher.with_message(/wrong/)
+    end
+  end
+
+  context 'when the subject is stubbed' do
+    it 'retains stubs on submatchers' do
+      subject = define_model :example, attr: :string do
+        validates_numericality_of :attr, odd: true
+        before_validation :set_attr!
+        def set_attr!; self.attr = 5 end
+      end.new
+
+      subject.stubs(:set_attr!)
+      expect(subject).to matcher.odd
+    end
+  end
+
+  describe '#description' do
+    context 'without submatchers' do
+      it { expect(matcher.description).to eq 'only allow numbers for attr' }
+    end
+
+    context 'with only integer option' do
+      it do
+        expect(matcher.only_integer.description)
+          .to eq 'only allow integers for attr'
+      end
+    end
+
+    [:odd, :even].each do |type|
+      context "with #{type} option" do
+        it do
+          expect(matcher.__send__(type).description)
+            .to eq "only allow #{type} numbers for attr"
+        end
+      end
+    end
+
+    [:is_greater_than,
+     :is_greater_than_or_equal_to,
+     :is_less_than,
+     :is_less_than_or_equal_to,
+     :is_equal_to ].each do |comparison|
+      context "with #{comparison} option" do
+        it do
+          expect(matcher.__send__(comparison, 18).description)
+          .to eq(
+            'only allow numbers for attr which are ' +
+            "#{comparison.to_s.sub('is_', '').gsub('_', ' ')} 18"
+          )
+        end
+      end
+    end
+
+    context 'with odd, is_greater_than_or_equal_to option' do
+      it do
+        expect(matcher.odd.is_greater_than_or_equal_to(18).description)
+          .to eq(
+            'only allow odd numbers for attr ' +
+            'which are greater than or equal to 18'
+          )
+      end
+    end
+
+    context 'with only integer, is_greater_than and less_than_or_equal_to option' do
+      it { expect(matcher.only_integer.is_greater_than(18).is_less_than_or_equal_to(100).description).
+          to eq "only allow integers for attr which are greater than 18 and less than or equal to 100" }
+    end
+  end
+
+
+  def validating_numericality(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, options
+    end.new
+  end
+
+  def not_validating_numericality
+    define_model(:example, attr: :string).new
+  end
+
+  def matcher
+    validate_numericality_of(:attr)
+  end
+end