shoulda-matchers 1.4.2 → 1.5.0

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
+  context '#description' do
+    it 'states that it allows only numeric values' do
+      matcher.description.should == 'only allow numeric values for attr'
+    end
+  end
+
+  context 'with a model with a numericality validation' do
+    it 'accepts' do
+      validating_numericality.should matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      validating_numericality.should matcher.with_message(nil)
+    end
+  end
+
+  context 'with a model without a numericality validation' do
+    it 'rejects' do
+      define_model(:example, :attr => :string).new.should_not matcher
+    end
+
+    it 'rejects with the ActiveRecord :not_an_integer message' do
+      the_matcher = matcher.only_integer
+
+      the_matcher.matches?(define_model(:example, :attr => :string).new)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
+    end
+  end
+
+  context 'with the only_integer option' do
+    it 'allows integer values for that attribute' do
+      validating_numericality(:only_integer => true).should matcher.only_integer
+    end
+
+    it 'rejects when the model does not enforce integer values' do
+      validating_numericality.should_not matcher.only_integer
+    end
+
+    it 'rejects with the ActiveRecord :not_an_integer message' do
+      the_matcher = matcher.only_integer
+
+      the_matcher.matches?(validating_numericality)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
+    end
+  end
+
+  context 'with a custom validation message' do
+    it 'accepts when the messages match' do
+      validating_numericality(:message => 'custom').
+        should matcher.with_message(/custom/)
+    end
+
+    it 'rejects when the messages do not match' do
+      validating_numericality(:message => 'custom').
+        should_not matcher.with_message(/wrong/)
+    end
+  end
+
+  def validating_numericality(options = {})
+    define_model :example, :attr => :string do
+      validates_numericality_of :attr, options
+    end.new
+  end
+
+  def matcher
+    validate_numericality_of(:attr)
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
+  context 'a model with a presence validation' do
+    it 'accepts' do
+      validating_presence.should matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      validating_presence.should matcher.with_message(nil)
+    end
+  end
+
+  context 'a model without a presence validation' do
+    it 'rejects' do
+      define_model(:example, :attr => :string).new.should_not matcher
+    end
+  end
+
+  context 'an ActiveModel class with a presence validation' do
+    it 'accepts' do
+      active_model_validating_presence.should matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      active_model_validating_presence.should matcher.with_message(nil)
+    end
+  end
+
+  context 'an ActiveModel class without a presence validation' do
+    it 'rejects' do
+      define_active_model_class('Example', :accessors => [:attr]).new.
+        should_not matcher
+    end
+  end
+
+  context 'a has_many association with a presence validation' do
+    it 'requires the attribute to be set' do
+      has_many_children(:presence => true).should validate_presence_of(:children)
+    end
+  end
+
+  context 'a has_many association without a presence validation' do
+    it 'does not require the attribute to be set' do
+      has_many_children(:presence => false).
+        should_not validate_presence_of(:children)
+    end
+  end
+
+  context 'a required has_and_belongs_to_many association' do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+        validates_presence_of :children
+      end.new
+      create_table 'children_parents', :id => false do |t|
+        t.integer :child_id
+        t.integer :parent_id
+      end
+    end
+
+    it 'accepts' do
+      @model.should validate_presence_of(:children)
+    end
+  end
+
+  context 'an optional has_and_belongs_to_many association' do
+    before do
+      define_model :child
+      @model = define_model :parent do
+        has_and_belongs_to_many :children
+      end.new
+      create_table 'children_parents', :id => false do |t|
+        t.integer :child_id
+        t.integer :parent_id
+      end
+    end
+
+    it 'rejects' do
+      @model.should_not validate_presence_of(:children)
+    end
+  end
+
+  if active_model_3_2?
+    context 'a strictly required attribute' do
+      it 'accepts when the :strict options match' do
+        validating_presence(:strict => true).should matcher.strict
+      end
+
+      it 'rejects when the :strict options do not match' do
+        validating_presence(:strict => false).should_not matcher.strict
+      end
+    end
+
+    it 'does not override the default message with a blank' do
+      validating_presence(:strict => true).
+        should matcher.strict.with_message(nil)
+    end
+  end
+
+  def matcher
+    validate_presence_of(:attr)
+  end
+
+  def validating_presence(options = {})
+    define_model :example, :attr => :string do
+      validates_presence_of :attr, options
+    end.new
+  end
+
+  def active_model_validating_presence
+    define_active_model_class('Example', :accessors => [:attr]) do
+      validates_presence_of :attr
+    end.new
+  end
+
+  def has_many_children(options = {})
+    define_model :child
+    define_model :parent do
+      has_many :children
+      if options[:presence]
+        validates_presence_of :children
+      end
+    end.new
+  end
+end

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

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
+  context 'a model without a a uniqueness validation' do
+    it 'rejects' do
+      model = define_model(:example, :attr => :string) { attr_accessible :attr } .new
+      Example.create!(:attr => 'value')
+      model.should_not matcher
+    end
+  end
+
+  context 'a model with a uniqueness validation' do
+    context 'with an existing record' do
+      it 'requires a unique value for that attribute' do
+        create_existing
+        validating_uniqueness_with_other.should matcher
+      end
+
+      it 'accepts when the subject is an existing record' do
+        create_existing.should matcher
+      end
+
+      it 'rejects when a scope is specified' do
+        create_existing
+        validating_uniqueness_with_other.should_not matcher.scoped_to(:other)
+      end
+
+      def create_existing
+        define_model_with_other
+        Example.create!(:attr => 'value', :other => 1)
+      end
+    end
+
+    context 'without an existing record' do
+      it 'does not require a created instance' do
+        define_model_with_other
+        Example.count.should == 0
+        validating_uniqueness_with_other.should matcher
+      end
+    end
+
+    def define_model_with_other(options = {})
+      @model ||= define_model(:example, :attr => :string, :other => :integer) do
+        attr_accessible :attr, :other
+        validates_uniqueness_of :attr, options
+      end
+    end
+
+    def validating_uniqueness_with_other(options = {})
+      define_model_with_other.new
+    end
+  end
+
+  context 'a model with a uniqueness validation, a custom error, and an existing record' do
+    it 'rejects when the actual message does not match the default message' do
+      validating_uniqueness_with_existing_record(:message => 'Bad value').
+        should_not matcher
+    end
+
+    it 'rejects when the messages do not match' do
+      validating_uniqueness_with_existing_record(:message => 'Bad value').
+        should_not matcher.with_message(/abc/)
+    end
+
+    it 'accepts when the messages match' do
+      validating_uniqueness_with_existing_record(:message => 'Bad value').
+        should matcher.with_message(/Bad/)
+    end
+
+    def validating_uniqueness_with_existing_record(options = {})
+      model = define_model(:example, :attr => :string) do
+        attr_accessible :attr
+        validates_uniqueness_of :attr, options
+      end.new
+      Example.create!(:attr => 'value')
+      model
+    end
+  end
+
+  context 'a model with a scoped uniqueness validation with an existing value' do
+    it 'accepts when the correct scope is specified' do
+      validating_scoped_uniqueness([:scope1, :scope2]).
+        should matcher.scoped_to(:scope1, :scope2)
+    end
+
+    it 'accepts when the subject is an existing record' do
+      define_scoped_model([:scope1, :scope2])
+      create_existing_record.should matcher.scoped_to(:scope1, :scope2)
+    end
+
+    it 'rejects when too narrow of a scope is specified' do
+      validating_scoped_uniqueness([:scope1, :scope2]).
+        should_not matcher.scoped_to(:scope1, :scope2, :other)
+    end
+
+    it 'rejects when too broad of a scope is specified' do
+      validating_scoped_uniqueness([:scope1, :scope2]).
+        should_not matcher.scoped_to(:scope1)
+    end
+
+    it 'rejects when a different scope is specified' do
+      validating_scoped_uniqueness([:scope1]).
+        should_not matcher.scoped_to(:other)
+    end
+
+    it 'rejects when no scope is specified' do
+      validating_scoped_uniqueness([:scope1]).should_not matcher
+    end
+
+    it 'rejects when a non-existent attribute is specified as a scope' do
+      validating_scoped_uniqueness([:scope1]).
+        should_not matcher.scoped_to(:fake)
+    end
+
+    def create_existing_record
+      @existing ||= Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3)
+    end
+
+    def define_scoped_model(scope)
+      define_model(:example, :attr => :string, :scope1 => :integer,
+        :scope2 => :integer, :other => :integer) do
+        attr_accessible :attr, :scope1, :scope2, :other
+        validates_uniqueness_of :attr, :scope => scope
+      end
+    end
+
+    def validating_scoped_uniqueness(scope)
+      model = define_scoped_model(scope).new
+      create_existing_record
+      model
+    end
+  end
+
+  context 'a model with a case-sensitive uniqueness validation on a string attribute and an existing record' do
+    it 'accepts a case-sensitive value for that attribute' do
+      case_sensitive_validation_with_existing_value(:string).
+        should matcher
+    end
+
+    it 'rejects a case-insensitive value for that attribute' do
+      case_sensitive_validation_with_existing_value(:string).
+        should_not matcher.case_insensitive
+    end
+  end
+
+  context 'a model with a case-sensitive uniqueness validation on an integer attribute with an existing value' do
+    it 'accepts a case-insensitive value for that attribute' do
+      case_sensitive_validation_with_existing_value(:integer).
+        should matcher.case_insensitive
+    end
+
+    it 'accepts a case-sensitive value for that attribute' do
+      case_sensitive_validation_with_existing_value(:integer).should matcher
+    end
+  end
+
+  def case_sensitive_validation_with_existing_value(attr_type)
+    model = define_model(:example, :attr => attr_type) do
+      attr_accessible :attr
+      validates_uniqueness_of :attr, :case_sensitive => true
+    end.new
+    if attr_type == :string
+      Example.create!(:attr => 'value')
+    elsif attr_type == :integer
+      Example.create!(:attr => 1)
+    else
+      raise 'Must be :string or :integer'
+    end
+    model
+  end
+
+  def matcher
+    validate_uniqueness_of(:attr)
+  end
+end

data/spec/shoulda/{active_model → matchers/active_model}/validation_message_finder_spec.rb

@@ -51,7 +51,6 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
   context '#messages_description' do
     it 'describes errors for the given attribute' do
-      value = 'xyz'
       finder = build_finder(
         :attribute => :attr,
         :format => /abc/,

data/spec/shoulda/matchers/active_record/accept_nested_attributes_for_matcher_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::AcceptNestedAttributesForMatcher do
+  it 'accepts an existing declaration' do
+    accepting_children.should accept_nested_attributes_for(:children)
+  end
+
+  it 'rejects a missing declaration' do
+    matcher = children_matcher
+
+    matcher.matches?(rejecting_children).should be_false
+
+    matcher.failure_message_for_should.should == 'Expected Parent to accept nested attributes for children (is not declared)'
+  end
+
+  context 'allow_destroy' do
+    it 'accepts a valid truthy value' do
+      matching = accepting_children(:allow_destroy => true)
+
+      matching.should children_matcher.allow_destroy(true)
+    end
+
+    it 'accepts a valid falsey value' do
+      matching = accepting_children(:allow_destroy => false)
+
+      matching.should children_matcher.allow_destroy(false)
+    end
+
+    it 'rejects an invalid truthy value' do
+      matcher = children_matcher
+      matching = accepting_children(:allow_destroy => true)
+
+      matcher.allow_destroy(false).matches?(matching).should be_false
+      matcher.failure_message_for_should.should =~ /should not allow destroy/
+    end
+
+    it 'rejects an invalid falsey value' do
+      matcher = children_matcher
+      matching = accepting_children(:allow_destroy => false)
+
+      matcher.allow_destroy(true).matches?(matching).should be_false
+      matcher.failure_message_for_should.should =~ /should allow destroy/
+    end
+  end
+
+  context 'limit' do
+    it 'accepts a correct value' do
+      accepting_children(:limit => 3).should children_matcher.limit(3)
+    end
+
+    it 'rejects a false value' do
+      matcher = children_matcher
+      rejecting = accepting_children(:limit => 3)
+
+      matcher.limit(2).matches?(rejecting).should be_false
+      matcher.failure_message_for_should.should =~ /limit should be 2, got 3/
+    end
+  end
+
+  context 'update_only' do
+    it 'accepts a valid truthy value' do
+      accepting_children(:update_only => true).
+        should children_matcher.update_only(true)
+    end
+
+    it 'accepts a valid falsey value' do
+      accepting_children(:update_only => false).
+        should children_matcher.update_only(false)
+    end
+
+    it 'rejects an invalid truthy value' do
+      matcher = children_matcher.update_only(false)
+      rejecting = accepting_children(:update_only => true)
+
+      matcher.matches?(rejecting).should be_false
+      matcher.failure_message_for_should.should =~ /should not be update only/
+    end
+
+    it 'rejects an invalid falsey value' do
+      matcher = children_matcher.update_only(true)
+      rejecting = accepting_children(:update_only => false)
+
+      matcher.matches?(rejecting).should be_false
+      matcher.failure_message_for_should.should =~ /should be update only/
+    end
+  end
+
+  def accepting_children(options = {})
+    define_model :child, :parent_id => :integer
+    define_model :parent do
+      has_many :children
+      accepts_nested_attributes_for :children, options
+    end.new
+  end
+
+  def children_matcher
+    accept_nested_attributes_for(:children)
+  end
+
+  def rejecting_children
+    define_model :child, :parent_id => :integer
+    define_model :parent do
+      has_many :children
+    end.new
+  end
+end