shoulda-matchers 1.3.0 → 1.4.0

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

@@ -0,0 +1,69 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+
+      # Finds message information from a model's #errors method.
+      class ValidationMessageFinder
+        include Helpers
+
+        def initialize(instance, attribute)
+          @instance = instance
+          @attribute = attribute
+        end
+
+        def allow_description(allowed_values)
+          "allow #{@attribute} to be set to #{allowed_values}"
+        end
+
+        def expected_message_from(attribute_message)
+          attribute_message
+        end
+
+        def has_messages?
+          errors.present?
+        end
+
+        def source_description
+          'errors'
+        end
+
+        def messages_description
+          if errors.empty?
+            "no errors"
+          else
+            "errors: #{pretty_error_messages(validated_instance)}"
+          end
+        end
+
+        def messages
+          Array.wrap(messages_for_attribute)
+        end
+
+        private
+
+        def messages_for_attribute
+          if errors.respond_to?(:[])
+            errors[@attribute]
+          else
+            errors.on(@attribute)
+          end
+        end
+
+        def errors
+          validated_instance.errors
+        end
+
+        def validated_instance
+          @validated_instance ||= validate_instance
+        end
+
+        def validate_instance
+          @instance.valid?
+          @instance
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -100,6 +100,11 @@ module Shoulda # :nodoc:
           self
         end
 
+        def with_foreign_key(foreign_key)
+          @options[:foreign_key] = foreign_key
+          self
+        end
+
         def validate(validate = true)
           @validate = validate
           self
@@ -243,7 +248,7 @@ module Shoulda # :nodoc:
 
         def join_table_exists?
           if @macro != :has_and_belongs_to_many ||
-              ::ActiveRecord::Base.connection.tables.include?(join_table)
+              model_class.connection.tables.include?(join_table)
             true
           else
             @missing = "join table #{join_table} doesn't exist"
@@ -261,11 +266,15 @@ module Shoulda # :nodoc:
         end
 
         def class_has_foreign_key?(klass)
-          if klass.column_names.include?(foreign_key)
-            true
+          if @options.key?(:foreign_key)
+            reflection.options[:foreign_key] == @options[:foreign_key]
           else
-            @missing = "#{klass} does not have a #{foreign_key} foreign key."
-            false
+            if klass.column_names.include?(foreign_key)
+              true
+            else
+              @missing = "#{klass} does not have a #{foreign_key} foreign key."
+              false
+            end
           end
         end
 

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

@@ -62,13 +62,16 @@ module Shoulda # :nodoc:
         def correct_unique?
           return true unless @options.key?(:unique)
 
-          if matched_index.unique == @options[:unique]
-            true
-          else
+          is_unique = matched_index.unique
+
+          is_unique = !is_unique unless @options[:unique]
+
+          unless is_unique
             @missing = "#{table_name} has an index named #{matched_index.name} " <<
-                       "of unique #{matched_index.unique}, not #{@options[:unique]}."
-            false
+            "of unique #{matched_index.unique}, not #{@options[:unique]}."
           end
+
+          is_unique
         end
 
         def matched_index

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '1.3.0'.freeze
+    VERSION = '1.4.0'.freeze
   end
 end

data/shoulda-matchers.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('appraisal',   '~> 0.4.0')
   s.add_development_dependency('aruba')
   s.add_development_dependency('bourne',      '~> 1.1.2')
-  s.add_development_dependency('bundler',     '~> 1.1.0')
+  s.add_development_dependency('bundler',     '~> 1.1')
   s.add_development_dependency('cucumber',    '~> 1.1.9')
   s.add_development_dependency('rails',       '~> 3.0')
   s.add_development_dependency('rake',        '~> 0.9.2')

data/spec/shoulda/action_controller/set_the_flash_matcher_spec.rb

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController::SetTheFlashMatcher do
+  it "should fail with unmatchable to" do
+    expect{
+      set_the_flash.to(1).should
+    }.to raise_error("cannot match against 1")
+  end
+
   context "a controller that sets a flash message" do
     let(:controller) { build_response { flash[:notice] = 'value' } }
 

data/spec/shoulda/active_model/allow_value_matcher_spec.rb

@@ -88,4 +88,36 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
       end.should raise_error(ArgumentError, /at least one argument/)
     end
   end
+
+  if Rails::VERSION::STRING.to_f >= 3.2
+    context "an attribute with a strict format validation" do
+      let(:model) do
+        define_model :example, :attr => :string do
+          validates_format_of :attr, :with => /abc/, :strict => true
+        end.new
+      end
+
+      it "strictly rejects a bad value" do
+        model.should_not allow_value("xyz").for(:attr).strict
+      end
+
+      it "strictly allows a bad value with a different message" do
+        model.should allow_value("xyz").for(:attr).with_message(/abc/).strict
+      end
+
+      it "describes itself" do
+        allow_value("xyz").for(:attr).strict.description.
+          should == %{doesn't raise when attr is set to "xyz"}
+      end
+
+      it "provides a useful negative failure message" do
+        matcher = allow_value("xyz").for(:attr).strict.with_message(/abc/)
+        matcher.matches?(model)
+        matcher.negative_failure_message.
+          should == 'Expected exception to include /abc/ ' +
+            'when attr is set to "xyz", got Attr is invalid'
+      end
+    end
+  end
+
 end

data/spec/shoulda/active_model/ensure_exclusion_of_matcher_spec.rb

@@ -51,7 +51,29 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
     it "should accept ensuring the correct range and messages" do
       @model.should ensure_exclusion_of(:attr).in_range(2..5).with_message(/shoud be out of this range/)
     end
-
   end
 
+  context "an attribute which must be excluded in an array" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_exclusion_of :attr, :in => %w(one two)
+      end.new
+    end
+
+    it "accepts with correct array" do
+      @model.should ensure_exclusion_of(:attr).in_array(%w(one two))
+    end
+
+    it "rejects when only part of array matches" do
+      @model.should_not ensure_exclusion_of(:attr).in_array(%w(one wrong_value))
+    end
+
+    it "rejects when array doesn't match at all" do
+      @model.should_not ensure_exclusion_of(:attr).in_array(%w(cat dog))
+    end
+
+    it "has correct description" do
+      ensure_exclusion_of(:attr).in_array([true, 'dog']).description.should == 'ensure exclusion of attr in [true, "dog"]'
+    end
+  end
 end

data/spec/shoulda/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -1,6 +1,24 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
+  context "with no validations" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+      end.new
+    end
+
+    it "should reject an array which does not have a validator defined" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(%w(Yes No))
+    end
+  end
+
+  context "where we cannot determine a value outside the array" do
+    it "should raise a custom exception" do
+      @model = define_model(:example, :attr => :string).new
+
+      expect { @model.should ensure_inclusion_of(:attr).in_array([""]) }.to raise_error Shoulda::Matchers::ActiveModel::CouldNotDetermineValueOutsideOfArray
+    end
+  end
 
   context "an attribute which must be included in a range" do
     before do
@@ -120,4 +138,35 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
       @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two']).allow_nil(false)
     end
   end
+
+  context "an attribute allowing some blank values but not others" do
+    before do
+      @model = define_model(:example, :attr => :string) do
+        validates_inclusion_of :attr, :in => ['one', 'two', '']
+      end.new
+    end
+
+    it "rejects allow_blank" do
+      @model.should_not ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(true)
+      @model.should ensure_inclusion_of(:attr).in_array(['one', 'two', '']).allow_blank(false)
+    end
+  end
+
+  if Rails::VERSION::STRING.to_f >= 3.2
+    context "a strict attribute which must be included in a range" do
+      before do
+        @model = define_model(:example, :attr => :integer) do
+          validates_inclusion_of :attr, :in => 2..5, :strict => true
+        end.new
+      end
+
+      it "should accept ensuring the correct range" do
+        @model.should ensure_inclusion_of(:attr).in_range(2..5).strict
+      end
+
+      it "should not accept ensuring another range" do
+        @model.should_not ensure_inclusion_of(:attr).in_range(2..6).strict
+      end
+    end
+  end
 end

data/spec/shoulda/active_model/ensure_length_of_matcher_spec.rb

@@ -86,6 +86,19 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
     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

data/spec/shoulda/active_model/exception_message_finder_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ExceptionMessageFinder do
+  if Rails::VERSION::STRING.to_f >= 3.2
+    context '#allow_description' do
+      it 'describes its attribute' do
+        finder = build_finder(:attribute => :attr)
+
+        description = finder.allow_description('allowed values')
+
+        description.should == "doesn't raise when attr is set to allowed values"
+      end
+    end
+
+    context '#expected_message_from' do
+      it 'returns the message with the attribute name prefixed' do
+        finder = build_finder(:attribute => :attr)
+
+        message = finder.expected_message_from('some message')
+
+        message.should == 'Attr some message'
+      end
+    end
+
+    context '#has_messages?' do
+      it 'has messages when some validations fail' do
+        finder = build_finder(:format => /abc/, :value => 'xyz')
+
+        result = finder.has_messages?
+
+        result.should be_true
+      end
+
+      it 'has no messages when all validations pass' do
+        finder = build_finder(:format => /abc/, :value => 'abc')
+
+        result = finder.has_messages?
+
+        result.should be_false
+      end
+    end
+
+    context '#messages' do
+      it 'returns errors for the given attribute' do
+        finder = build_finder(
+          :attribute => :attr,
+          :format => /abc/,
+          :value => 'xyz'
+        )
+
+        messages = finder.messages
+
+        messages.should == ['Attr is invalid']
+      end
+    end
+
+    context '#messages_description' do
+      it 'describes errors for the given attribute' do
+        finder = build_finder(
+          :attribute => :attr,
+          :format => /abc/,
+          :value => 'xyz'
+        )
+
+        description = finder.messages_description
+
+        description.should == 'Attr is invalid'
+      end
+
+      it 'describes errors when there are none' do
+        finder = build_finder(:format => /abc/, :value => 'abc')
+
+        description = finder.messages_description
+
+        description.should == 'no exception'
+      end
+    end
+
+    context '#source_description' do
+      it 'describes the source of its messages' do
+        finder = build_finder
+
+        description = finder.source_description
+
+        description.should == 'exception'
+      end
+    end
+  end
+
+  def build_finder(arguments = {})
+    arguments[:attribute] ||= :attr
+    instance = build_instance_validating(
+      arguments[:attribute],
+      arguments[:format] || /abc/,
+      arguments[:value] || 'abc'
+    )
+    Shoulda::Matchers::ActiveModel::ExceptionMessageFinder.new(
+      instance,
+      arguments[:attribute]
+    )
+  end
+
+  def build_instance_validating(attribute, format, value)
+    model_class = define_model(:example, attribute => :string) do
+      attr_accessible attribute
+      validates_format_of attribute, :with => format, :strict => true
+    end
+
+    model_class.new(attribute => value)
+  end
+end
+

data/spec/shoulda/active_model/validate_presence_of_matcher_spec.rb

@@ -117,4 +117,19 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     end
   end
 
+  if Rails::VERSION::STRING.to_f >= 3.2
+    context "a strictly required attribute" do
+      before do
+        define_model :example, :attr => :string do
+          validates_presence_of :attr, :strict => true
+        end
+        @model = Example.new
+      end
+
+      it "should require a value" do
+        @model.should validate_presence_of(:attr).strict
+      end
+    end
+  end
+
 end