shoulda-matchers 2.2.0 → 2.3.0

data/lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -0,0 +1,35 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class CounterCacheMatcher
+          attr_accessor :missing_option
+
+          def initialize(counter_cache, name)
+            @counter_cache = counter_cache
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "counter_cache => #{counter_cache}"
+          end
+
+          def matches?(subject)
+            subject = ModelReflector.new(subject, name)
+
+            if subject.option_set_properly?(counter_cache, :counter_cache)
+              true
+            else
+              self.missing_option = "#{name} should have #{description}"
+              false
+            end
+          end
+
+          private
+          attr_accessor :counter_cache, :name
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/dependent_matcher.rb

@@ -0,0 +1,35 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class DependentMatcher
+          attr_accessor :missing_option
+
+          def initialize(dependent, name)
+            @dependent = dependent
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "dependent => #{dependent}"
+          end
+
+          def matches?(subject)
+            subject = ModelReflector.new(subject, name)
+
+            if dependent.nil? || subject.option_set_properly?(dependent, :dependent)
+              true
+            else
+              self.missing_option = "#{name} should have #{dependent} dependency"
+              false
+            end
+          end
+
+          private
+          attr_accessor :dependent, :name
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/model_reflector.rb

@@ -0,0 +1,37 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class ModelReflector
+          def initialize(subject, name)
+            @subject = subject
+            @name = name
+          end
+
+          def reflection
+            @reflection ||= reflect_on_association(name)
+          end
+
+          def reflect_on_association(name)
+            model_class.reflect_on_association(name)
+          end
+
+          def model_class
+            subject.class
+          end
+
+          def option_string(key)
+            reflection.options[key].to_s
+          end
+
+          def option_set_properly?(option, option_key)
+            option.to_s == option_string(option_key)
+          end
+
+          private
+          attr_reader :subject, :name
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/order_matcher.rb

@@ -0,0 +1,35 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class OrderMatcher
+          attr_accessor :missing_option
+
+          def initialize(order, name)
+            @order = order
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "order => #{order}"
+          end
+
+          def matches?(subject)
+            subject = ModelReflector.new(subject, name)
+
+            if subject.option_set_properly?(order, :order)
+              true
+            else
+              self.missing_option = "#{name} should be ordered by #{order}"
+              false
+            end
+          end
+
+          private
+          attr_accessor :order, :name
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/association_matchers/through_matcher.rb

@@ -0,0 +1,57 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class ThroughMatcher
+          attr_accessor :missing_option
+
+          def initialize(through, name)
+            @through = through
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "through #{through}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+            through.nil? || association_set_properly?
+          end
+
+          def association_set_properly?
+            through_association_exists? && through_association_correct?
+          end
+
+          def through_association_exists?
+            if through_reflection.present?
+              true
+            else
+              self.missing_option = "#{name} does not have any relationship to #{through}"
+              false
+            end
+          end
+
+          def through_reflection
+            @through_reflection ||= subject.reflect_on_association(through)
+          end
+
+          def through_association_correct?
+            if subject.option_set_properly?(through, :through)
+              true
+            else
+              self.missing_option =
+                "Expected #{name} to have #{name} through #{through}, " +
+                "but got it through #{subject.option_string(:through)}"
+              false
+            end
+          end
+
+          private
+          attr_accessor :through, :name, :subject
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '2.2.0'.freeze
+    VERSION = '2.3.0'.freeze
   end
 end

data/spec/shoulda/matchers/action_controller/rescue_from_matcher_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RescueFromMatcher do
+  context 'a controller that rescues from RuntimeError' do
+    it "asserts controller is setup with rescue_from" do
+      controller_with_rescue_from.should rescue_from RuntimeError
+    end
+
+    context 'with a handler method' do
+      it "asserts rescue_from was set up with handler method" do
+        controller_with_rescue_from_and_method.should rescue_from(RuntimeError).with(:error_method)
+      end
+
+      it "asserts rescue_from was not set up with incorrect handler method" do
+        controller_with_rescue_from_and_method.should_not rescue_from(RuntimeError).with(:other_method)
+      end
+
+      it "asserts the controller responds to the handler method" do
+        matcher = rescue_from(RuntimeError).with(:error_method)
+        matcher.matches?(controller_with_rescue_from_and_invalid_method).should be_false
+        matcher.failure_message_for_should.should =~ /does not respond to/
+      end
+    end
+
+    context 'without a handler method' do
+      it "the handler method is not included in the description" do
+        matcher = rescue_from(RuntimeError)
+        matcher.matches?(controller_with_rescue_from).should be_true
+        matcher.description.should_not =~ /with #/
+      end
+    end
+  end
+
+  context 'a controller that does not rescue from RuntimeError' do
+    it "asserts controller is not setup with rescue_from" do
+      matcher = rescue_from RuntimeError
+      define_controller("RandomController").should_not matcher
+      matcher.failure_message_for_should_not.should =~ /Did not expect \w+ to rescue from/
+    end
+  end
+
+  def controller_with_rescue_from
+    define_controller "RescueRuntimeError" do
+      rescue_from(RuntimeError) {}
+    end
+  end
+
+  def controller_with_rescue_from_and_invalid_method
+    define_controller "RescueRuntimeErrorWithMethod" do
+      rescue_from RuntimeError, with: :error_method
+    end
+  end
+
+  def controller_with_rescue_from_and_method
+    controller = controller_with_rescue_from_and_invalid_method
+    class << controller
+      def error_method
+        true
+      end
+    end
+    controller
+  end
+end

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

@@ -110,7 +110,7 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
       matcher = described_class.new('foo').for(:attr)
       matcher.description
 
-      expect { matcher.matches?(model) }.not_to raise_error(NoMethodError)
+      expect { matcher.matches?(model) }.not_to raise_error
     end
   end
 

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

@@ -21,6 +21,11 @@ describe Shoulda::Matchers::ActiveModel::ComparisonMatcher do
     it { instance_without_validations.should_not matcher.is_less_than_or_equal_to(2) }
   end
 
+  context 'is_equal_to' do
+    it { instance_with_validations(:equal_to => 0).should matcher.is_equal_to(0) }
+    it { instance_without_validations.should_not matcher.is_equal_to(0) }
+  end
+
   def instance_with_validations(options = {})
     define_model :example, :attr => :string do
       validates_numericality_of :attr, options

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

@@ -15,6 +15,24 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
     end
   end
 
+  context "an attribute with a context-dependent validation" do
+    context "without the validation context" do
+      it "does not match" do
+        validating_format(:with => /abc/, :on => :customisable).should_not matcher("xyz").for(:attr)
+      end
+    end
+
+    context "with the validation context" do
+      it "disallows a bad value" do
+        validating_format(:with => /abc/, :on => :customisable).should matcher("xyz").for(:attr).on(:customisable)
+      end
+
+      it "does not match a good value" do
+        validating_format(:with => /abc/, :on => :customisable).should_not 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
       validating_format(:with => /abc/, :message => 'good message').

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

@@ -8,6 +8,16 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
     end
   end
 
+  context 'with an integer column' do
+    it 'can verify a zero in the array' do
+      model = define_model(:example, :attr => :integer) do
+        validates_inclusion_of :attr, :in => [0, 1, 2]
+      end.new
+
+      model.should ensure_inclusion_of(:attr).in_array([0,1,2])
+    end
+  end
+
   context 'with true/false values' do
     it 'can verify outside values to ensure the negative case' do
       define_model(:example, :attr => :string).new.

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

@@ -118,7 +118,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
       it "does not raise an exception" do
         expect {
           validating_length(:maximum => 4).should ensure_length_of(:attr).is_at_most(4)
-        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+        }.to_not raise_exception
       end
     end
 
@@ -132,7 +132,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
       it "does not raise an exception" do
         expect {
           validating_length(:minimum => 4).should ensure_length_of(:attr).is_at_least(4)
-        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+        }.to_not raise_exception
       end
     end
 
@@ -146,7 +146,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
       it "does not raise an exception" do
         expect {
           validating_length(:is => 4).should ensure_length_of(:attr).is_equal_to(4)
-        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+        }.to_not raise_exception
       end
     end
   end

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

@@ -121,6 +121,19 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
     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!)
+      subject.should matcher.odd
+    end
+  end
+
   def validating_numericality(options = {})
     define_model :example, :attr => :string do
       validates_numericality_of :attr, options

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

@@ -120,6 +120,20 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     end
   end
 
+  context "an attribute with a context-dependent validation" do
+    context "without the validation context" do
+      it "does not match" do
+        validating_presence(:on => :customisable).should_not matcher
+      end
+    end
+
+    context "with the validation context" do
+      it "matches" do
+        validating_presence(:on => :customisable).should matcher.on(:customisable)
+      end
+    end
+  end
+
   def matcher
     validate_presence_of(:attr)
   end

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

@@ -131,6 +131,13 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
             should_not matcher.scoped_to(:scope1, :scope2, :other)
         end
       end
+
+      context 'when too broad of a scope is specified' do
+        it 'rejects' do
+          validating_scoped_uniqueness([:scope1, :scope2], :date, :scope1 => Date.today, :scope2 => Date.today).
+            should_not matcher.scoped_to(:scope1)
+        end
+      end
     end
 
     context 'when the scoped attribute is a datetime' do
@@ -160,12 +167,53 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
         end
       end
 
+      context 'when too broad of a scope is specified' do
+        it 'rejects' do
+          validating_scoped_uniqueness([:scope1, :scope2], :datetime, :scope1 => DateTime.now, :scope2 => DateTime.now).
+            should_not matcher.scoped_to(:scope1)
+        end
+      end
+    end
+
+    context 'when the scoped attribute is a uuid' do
+      it 'accepts' do
+        validating_scoped_uniqueness([:scope1], :uuid, :scope1 => SecureRandom.uuid).
+          should matcher.scoped_to(:scope1)
+      end
+
       context 'with an existing record that conflicts with scope.next' do
         it 'accepts' do
-          validating_scoped_uniqueness_with_conflicting_next(:scope1, :scope1 => 1).
+          validating_scoped_uniqueness_with_conflicting_next(:scope1, :uuid, :scope1 => SecureRandom.uuid).
             should matcher.scoped_to(:scope1)
         end
       end
+
+      context 'with a nil value' do
+        it 'accepts' do
+          validating_scoped_uniqueness([:scope1], :uuid, :scope1 => nil).
+            should matcher.scoped_to(:scope1)
+        end
+      end
+
+      context 'when too narrow of a scope is specified' do
+        it 'rejects' do
+          record = validating_scoped_uniqueness([:scope1, :scope2], :uuid,
+            :scope1 => SecureRandom.uuid,
+            :scope2 => SecureRandom.uuid
+          )
+          record.should_not matcher.scoped_to(:scope1, :scope2, :other)
+        end
+      end
+
+      context 'when too broad of a scope is specified' do
+        it 'rejects' do
+          record = validating_scoped_uniqueness([:scope1, :scope2], :uuid,
+            :scope1 => SecureRandom.uuid,
+            :scope2 => SecureRandom.uuid
+          )
+          record.should_not matcher.scoped_to(:scope1)
+        end
+      end
     end
 
     def create_existing_record(attributes = {})