shoulda-matchers 2.0.0 → 2.1.0

data/lib/shoulda/matchers/active_model/only_integer_matcher.rb

@@ -27,6 +27,10 @@ module Shoulda # :nodoc:
         def failure_message_for_should
           @disallow_value_matcher.failure_message_for_should
         end
+
+        def failure_message_for_should_not
+          @disallow_value_matcher.failure_message_for_should_not
+        end
       end
     end
   end

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -8,10 +8,14 @@ module Shoulda # :nodoc:
       #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
       #   translation for <tt>:not_a_number</tt>.
       # * <tt>only_integer</tt> - allows only integer values
+      # * <tt>odd</tt> - Specifies the value must be an odd number.
+      # * <tt>even</tt> - Specifies the value must be an even number.
       #
       # Examples:
       #   it { should validate_numericality_of(:price) }
       #   it { should validate_numericality_of(:age).only_integer }
+      #   it { should validate_numericality_of(:frequency).odd }
+      #   it { should validate_numericality_of(:frequency).even }
       #
       def validate_numericality_of(attr)
         ValidateNumericalityOfMatcher.new(attr)
@@ -22,7 +26,6 @@ module Shoulda # :nodoc:
 
         def initialize(attribute)
           @attribute = attribute
-          @options = {}
           @submatchers = []
 
           add_disallow_value_matcher
@@ -34,6 +37,18 @@ module Shoulda # :nodoc:
           self
         end
 
+        def odd
+          odd_number_matcher = OddEvenNumberMatcher.new(@attribute, :odd => true)
+          add_submatcher(odd_number_matcher)
+          self
+        end
+
+        def even
+          even_number_matcher = OddEvenNumberMatcher.new(@attribute, :even => true)
+          add_submatcher(even_number_matcher)
+          self
+        end
+
         def with_message(message)
           @submatchers.each { |matcher| matcher.with_message(message) }
           self
@@ -49,7 +64,11 @@ module Shoulda # :nodoc:
         end
 
         def failure_message_for_should
-          submatcher_failure_messages.last
+          submatcher_failure_messages_for_should.last
+        end
+
+        def failure_message_for_should_not
+          submatcher_failure_messages_for_should_not.last
         end
 
         private
@@ -70,10 +89,14 @@ module Shoulda # :nodoc:
           failing_submatchers.empty?
         end
 
-        def submatcher_failure_messages
+        def submatcher_failure_messages_for_should
           failing_submatchers.map(&:failure_message_for_should)
         end
 
+        def submatcher_failure_messages_for_should_not
+          failing_submatchers.map(&:failure_message_for_should_not)
+        end
+
         def failing_submatchers
           @failing_submatchers ||= @submatchers.select { |matcher| !matcher.matches?(@subject) }
         end

data/lib/shoulda/matchers/active_model/validate_uniqueness_of_matcher.rb

@@ -55,12 +55,26 @@ module Shoulda # :nodoc:
           self
         end
 
+        def allow_nil
+          @options[:allow_nil] = true
+          self
+        end
+
+        def description
+          result = "require "
+          result << "case sensitive " unless @options[:case_insensitive]
+          result << "unique value for #{@attribute}"
+          result << " scoped to #{@options[:scopes].join(', ')}" if @options[:scopes].present?
+          result
+        end
+
         def matches?(subject)
           @subject = subject.class.new
           @expected_message ||= :taken
           set_scoped_attributes &&
-            validate_attribute? &&
-            validate_after_scope_change?
+            validate_everything_except_duplicate_nils? &&
+            validate_after_scope_change? &&
+            allows_nil?
         end
 
         def description
@@ -73,17 +87,42 @@ module Shoulda # :nodoc:
 
         private
 
-        def existing
-          @existing ||= first_instance
+        def allows_nil?
+          if @options[:allow_nil]
+            ensure_nil_record_in_database
+            allows_value_of(nil, @expected_message)
+          else
+            true
+          end
+        end
+
+        def existing_record
+          @existing_record ||= first_instance
         end
 
         def first_instance
-          @subject.class.first || create_instance_in_database
+          @subject.class.first || create_record_in_database
         end
 
-        def create_instance_in_database
+        def ensure_nil_record_in_database
+          unless existing_record_is_nil?
+            create_record_in_database(nil_value: true)
+          end
+        end
+
+        def existing_record_is_nil?
+          @existing_record.present? && existing_value.nil?
+        end
+
+        def create_record_in_database(options = {})
+          if options[:nil_value]
+            value = nil
+          else
+            value = "arbitrary_string"
+          end
+
           @subject.class.new.tap do |instance|
-            instance.send("#{@attribute}=", 'arbitrary_string')
+            instance.send("#{@attribute}=", value)
             instance.save(:validate => false)
           end
         end
@@ -93,7 +132,7 @@ module Shoulda # :nodoc:
             @options[:scopes].all? do |scope|
               setter = :"#{scope}="
               if @subject.respond_to?(setter)
-                @subject.send(setter, existing.send(scope))
+                @subject.send(setter, existing_record.send(scope))
                 true
               else
                 @failure_message_for_should = "#{class_name} doesn't seem to have a #{scope} attribute."
@@ -105,10 +144,18 @@ module Shoulda # :nodoc:
           end
         end
 
-        def validate_attribute?
+        def validate_everything_except_duplicate_nils?
+          if @options[:allow_nil] && existing_value.nil?
+            create_record_without_nil
+          end
+
           disallows_value_of(existing_value, @expected_message)
         end
 
+        def create_record_without_nil
+          @existing_record = create_record_in_database
+        end
+
         # TODO:  There is a chance that we could change the scoped field
         # to a value that's already taken.  An alternative implementation
         # could actually find all values for scope and create a unique
@@ -117,16 +164,19 @@ module Shoulda # :nodoc:
             true
           else
             @options[:scopes].all? do |scope|
-              previous_value = existing.send(scope)
+              previous_value = existing_record.send(scope)
 
               # Assume the scope is a foreign key if the field is nil
               previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
 
-              next_value = if previous_value.respond_to?(:next)
-                previous_value.next
-              else
-                previous_value.to_s.next
-              end
+              next_value =
+                if previous_value.respond_to?(:next)
+                  previous_value.next
+                elsif previous_value.respond_to?(:to_datetime)
+                  previous_value.to_datetime.next
+                else
+                  previous_value.to_s.next
+                end
 
               @subject.send("#{scope}=", next_value)
 
@@ -147,6 +197,8 @@ module Shoulda # :nodoc:
         def correct_type_for_column(column)
           if column.type == :string
             '0'
+          elsif column.type == :datetime
+            DateTime.now
           else
             0
           end
@@ -157,7 +209,7 @@ module Shoulda # :nodoc:
         end
 
         def existing_value
-          value = existing.send(@attribute)
+          value = existing_record.send(@attribute)
           if @options[:case_insensitive] && value.respond_to?(:swapcase!)
             value.swapcase!
           end

data/lib/shoulda/matchers/active_model/validation_matcher.rb

@@ -9,6 +9,11 @@ module Shoulda # :nodoc:
           @strict = false
         end
 
+        def on(context)
+          @context = context
+          self
+        end
+
         def strict
           @strict = true
           self

data/lib/shoulda/matchers/active_model/validation_message_finder.rb

@@ -6,9 +6,10 @@ module Shoulda
       class ValidationMessageFinder
         include Helpers
 
-        def initialize(instance, attribute)
+        def initialize(instance, attribute, context=nil)
           @instance = instance
           @attribute = attribute
+          @context = context
         end
 
         def allow_description(allowed_values)
@@ -58,7 +59,7 @@ module Shoulda
         end
 
         def validate_instance
-          @instance.valid?
+          @instance.valid?(@context)
           @instance
         end
       end

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -7,6 +7,8 @@ module Shoulda # :nodoc:
       # * <tt>:class_name</tt> - tests that the association resolves to class_name.
       # * <tt>:validate</tt> - tests that the association makes use of the validate
       # option.
+      # * <tt>:touch</tt> - tests that the association makes use of the touch
+      # option.
       #
       # Example:
       #   it { should belong_to(:parent) }
@@ -107,7 +109,12 @@ module Shoulda # :nodoc:
         end
 
         def validate(validate = true)
-          @validate = validate
+          @options[:validate] = validate
+          self
+        end
+
+        def touch(touch = true)
+          @options[:touch] = touch
           self
         end
 
@@ -122,7 +129,8 @@ module Shoulda # :nodoc:
             order_correct? &&
             conditions_correct? &&
             join_table_exists? &&
-            validate_correct?
+            validate_correct? &&
+            touch_correct?
         end
 
         def failure_message_for_should
@@ -258,14 +266,31 @@ module Shoulda # :nodoc:
         end
 
         def validate_correct?
-          if !@validate && !reflection.options[:validate] || @validate == reflection.options[:validate]
+          if option_correct?(:validate)
+            true
+          else
+            @missing = "#{@name} should have :validate => #{@options[:validate]}"
+            false
+          end
+        end
+
+        def touch_correct?
+          if option_correct?(:touch)
             true
           else
-            @missing = "#{@name} should have :validate => #{@validate}"
+            @missing = "#{@name} should have :touch => #{@options[:touch]}"
             false
           end
         end
 
+        def option_correct?(key)
+          !@options.key?(key) || reflection_set_properly_for?(key)
+        end
+
+        def reflection_set_properly_for?(key)
+          @options[key] == !!reflection.options[key]
+        end
+
         def class_has_foreign_key?(klass)
           if @options.key?(:foreign_key)
             reflection.options[:foreign_key] == @options[:foreign_key]

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '2.0.0'.freeze
+    VERSION = '2.1.0'.freeze
   end
 end

data/shoulda-matchers.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.required_ruby_version = '>= 1.9.2'
   s.add_dependency('activesupport', '>= 3.0.0')
 
   s.add_development_dependency('appraisal',   '~> 0.4')

data/spec/shoulda/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
+  context "a unique attribute" do
+    before do
+      @model = define_model(:example, :attr  => :string,
+                                      :other => :integer) do
+        attr_accessible :attr, :other
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "with an existing value" do
+      before do
+        @existing = Example.create!(:attr => 'value', :other => 1)
+      end
+
+      it "should require a unique value for that attribute" do
+        @model.should validate_uniqueness_of(:attr)
+      end
+
+      it "should pass when the subject is an existing record" do
+        @existing.should validate_uniqueness_of(:attr)
+      end
+
+      it "should fail when a scope is specified" do
+        @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
+      end
+    end
+
+    context "without an existing value" do
+      before do
+        Example.first.should be_nil
+        @matcher = validate_uniqueness_of(:attr)
+      end
+
+      it "does not not require a created instance" do
+        @model.should @matcher
+      end
+    end
+  end
+
+  context "a unique attribute with a custom error and an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :message => 'Bad value'
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should fail when checking the default message" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when checking a message that doesn't match" do
+      @model.should_not validate_uniqueness_of(:attr).with_message(/abc/i)
+    end
+
+    it "should pass when checking a message that matches" do
+      @model.should validate_uniqueness_of(:attr).with_message(/bad/i)
+    end
+  end
+
+  context "a scoped unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr   => :string,
+                                      :scope1 => :integer,
+                                      :scope2 => :integer,
+                                      :other => :integer) do
+        attr_accessible :attr, :scope1, :scope2, :other
+        validates_uniqueness_of :attr, :scope => [:scope1, :scope2]
+      end.new
+      @existing = Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3)
+    end
+
+    it "should pass when the correct scope is specified" do
+      @model.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should pass when the subject is an existing record" do
+      @existing.should validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2)
+    end
+
+    it "should fail when too narrow of a scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1, :scope2, :other)
+    end
+
+    it "should fail when too broad of a scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:scope1)
+    end
+
+    it "should fail when a different scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:other)
+    end
+
+    it "should fail when no scope is specified" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+
+    it "should fail when a non-existent attribute is specified as a scope" do
+      @model.should_not validate_uniqueness_of(:attr).scoped_to(:fake)
+    end
+  end
+
+  context "a non-unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :string) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should not require a unique, case-insensitive value for that attribute" do
+      @model.should_not validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "a case sensitive unique integer attribute with an existing value" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :case_sensitive => true
+      end.new
+      Example.create!(:attr => 'value')
+    end
+
+    it "should require a unique, case-insensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr).case_insensitive
+    end
+
+    it "should require a unique, case-sensitive value for that attribute" do
+      @model.should validate_uniqueness_of(:attr)
+    end
+  end
+
+  context "when the validation allows nil" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, :allow_nil => true
+      end.new
+    end
+
+    context "when there is an existing entry with a nil" do
+      it "should allow_nil" do
+        Example.create!(:attr => nil)
+        @model.should validate_uniqueness_of(:attr).allow_nil
+      end
+    end
+
+    it "should create a nil and verify that it is allowed" do
+      @model.should validate_uniqueness_of(:attr).allow_nil
+      Example.all.any?{ |instance| instance.attr.nil? }
+    end
+  end
+
+  context "when the validation does not allow a nil" do
+    before do
+      @model = define_model(:example, :attr  => :integer) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr
+      end.new
+    end
+
+    context "when there is an existing entry with a nil" do
+      it "should not allow_nil" do
+        Example.create!(:attr => nil)
+        @model.should_not validate_uniqueness_of(:attr).allow_nil
+      end
+    end
+
+    it "should not allow_nil" do
+      @model.should_not validate_uniqueness_of(:attr).allow_nil
+    end
+  end
+end