shoulda-matchers 2.4.0 → 2.5.0

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

@@ -3,6 +3,9 @@ module Shoulda # :nodoc:
     module ActiveRecord # :nodoc:
       module AssociationMatchers
         class ModelReflector
+          delegate :associated_class, :through?, :join_table,
+            :association_relation, to: :reflection
+
           def initialize(subject, name)
             @subject = subject
             @name = name
@@ -13,55 +16,15 @@ module Shoulda # :nodoc:
           end
 
           def reflect_on_association(name)
-            model_class.reflect_on_association(name)
-          end
-
-          def model_class
-            subject.class
-          end
+            reflection = model_class.reflect_on_association(name)
 
-          def associated_class
-            reflection.klass
-          end
-
-          def through?
-            reflection.options[:through]
-          end
-
-          def join_table
-            if reflection.respond_to? :join_table
-              reflection.join_table.to_s
-            else
-              reflection.options[:join_table].to_s
+            if reflection
+              ModelReflection.new(reflection)
             end
           end
 
-          def association_relation
-            if reflection.respond_to?(:scope) && reflection.scope
-              relation_from_scope(reflection.scope)
-            else
-              options = reflection.options
-              relation = RailsShim.clean_scope(reflection.klass)
-              if options[:conditions]
-                relation = relation.where(options[:conditions])
-              end
-              if options[:include]
-                relation = relation.include(options[:include])
-              end
-              if options[:order]
-                relation = relation.order(options[:order])
-              end
-              if options[:group]
-                relation = relation.group(options[:group])
-              end
-              if options[:having]
-                relation = relation.having(options[:having])
-              end
-              if options[:limit]
-                relation = relation.limit(options[:limit])
-              end
-              relation
-            end
+          def model_class
+            subject.class
           end
 
           def build_relation_with_clause(name, value)
@@ -74,24 +37,26 @@ module Shoulda # :nodoc:
 
           def extract_relation_clause_from(relation, name)
             case name
-              when :conditions then relation.where_values_hash
-              when :order      then relation.order_values.join(', ')
-              else                  raise ArgumentError, "Unknown clause '#{name}'"
+            when :conditions
+              relation.where_values_hash
+            when :order
+              relation.order_values.map { |value| value_as_sql(value) }.join(', ')
+            else
+              raise ArgumentError, "Unknown clause '#{name}'"
             end
           end
 
           private
 
-          def relation_from_scope(scope)
-            # Source: AR::Associations::AssociationScope#eval_scope
-            if scope.is_a?(::Proc)
-              associated_class.all.instance_exec(subject, &scope)
+          attr_reader :subject, :name
+
+          def value_as_sql(value)
+            if value.respond_to?(:to_sql)
+              value.to_sql
             else
-              scope
+              value
             end
           end
-
-          attr_reader :subject, :name
         end
       end
     end

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

@@ -0,0 +1,40 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class SourceMatcher
+          attr_accessor :missing_option
+
+          def initialize(source, name)
+            @source = source
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "source => #{source}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:source, source)
+              true
+            else
+              self.missing_option = "#{name} should have #{source} as source option"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :source, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,13 +51,15 @@ module Shoulda # :nodoc:
             correct_primary?
         end
 
-        def failure_message_for_should
+        def failure_message
           "Expected #{expectation} (#{@missing})"
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "Did not expect #{expectation}"
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           desc = "have db column named #{@column}"

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

@@ -37,13 +37,15 @@ module Shoulda # :nodoc:
           index_exists? && correct_unique?
         end
 
-        def failure_message_for_should
+        def failure_message
           "Expected #{expectation} (#{@missing})"
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "Did not expect #{expectation}"
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           if @options.key?(:unique)

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

@@ -16,19 +16,22 @@ module Shoulda # :nodoc:
           @attribute = attribute.to_s
         end
 
-        attr_reader :failure_message_for_should, :failure_message_for_should_not
+        attr_reader :failure_message, :failure_message_when_negated
+
+        alias failure_message_for_should failure_message
+        alias failure_message_for_should_not failure_message_when_negated
 
         def matches?(subject)
           @subject = subject
           if readonly_attributes.include?(@attribute)
-            @failure_message_for_should_not = "Did not expect #{@attribute} to be read-only"
+            @failure_message_when_negated = "Did not expect #{@attribute} to be read-only"
             true
           else
             if readonly_attributes.empty?
-              @failure_message_for_should = "#{class_name} attribute #{@attribute} " <<
+              @failure_message = "#{class_name} attribute #{@attribute} " <<
                 'is not read-only'
             else
-              @failure_message_for_should = "#{class_name} is making " <<
+              @failure_message = "#{class_name} is making " <<
                 "#{readonly_attributes.to_a.to_sentence} " <<
                 "read-only, but not #{@attribute}."
             end

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

@@ -36,13 +36,15 @@ module Shoulda # :nodoc:
           serialization_valid? && type_valid?
         end
 
-        def failure_message_for_should
+        def failure_message
           "Expected #{expectation} (#{@missing})"
         end
+        alias failure_message_for_should failure_message
 
-        def failure_message_for_should_not
+        def failure_message_when_negated
           "Did not expect #{expectation}"
         end
+        alias failure_message_for_should_not failure_message_when_negated
 
         def description
           description = "serialize :#{@name}"

data/lib/shoulda/matchers/integrations/test_unit.rb

@@ -1,4 +1,4 @@
-if defined?(ActionController)
+if defined?(ActionController) && defined?(ActionController::TestCase)
   require 'shoulda/matchers/action_controller'
 
   ActionController::TestCase.class_eval do
@@ -11,7 +11,7 @@ if defined?(ActionController)
   end
 end
 
-if defined?(ActiveRecord)
+if defined?(ActiveRecord) && defined?(ActiveSupport::TestCase)
   require 'shoulda/matchers/active_record'
 
   ActiveSupport::TestCase.class_eval do
@@ -20,7 +20,7 @@ if defined?(ActiveRecord)
   end
 end
 
-if defined?(ActiveModel)
+if defined?(ActiveModel) && defined?(ActiveSupport::TestCase)
   require 'shoulda/matchers/active_model'
 
   ActiveSupport::TestCase.class_eval do

data/lib/shoulda/matchers/rails_shim.rb

@@ -2,7 +2,7 @@ module Shoulda # :nodoc:
   module Matchers
     class RailsShim # :nodoc:
       def self.layouts_ivar
-        if rails_major_version >= 4
+        if action_pack_major_version >= 4
           '@_layouts'
         else
           '@layouts'
@@ -10,7 +10,7 @@ module Shoulda # :nodoc:
       end
 
       def self.flashes_ivar
-        if rails_major_version >= 4
+        if action_pack_major_version >= 4
           :@flashes
         else
           :@used
@@ -18,7 +18,7 @@ module Shoulda # :nodoc:
       end
 
       def self.clean_scope(klass)
-        if rails_major_version == 4
+        if active_record_major_version == 4
           klass.all
         else
           klass.scoped
@@ -26,15 +26,23 @@ module Shoulda # :nodoc:
       end
 
       def self.validates_confirmation_of_error_attribute(matcher)
-        if rails_major_version == 4
+        if active_model_major_version == 4
           matcher.confirmation_attribute
         else
           matcher.attribute
         end
       end
 
-      def self.rails_major_version
-        Rails::VERSION::MAJOR
+      def self.active_record_major_version
+        ::ActiveRecord::VERSION::MAJOR
+      end
+
+      def self.active_model_major_version
+        ::ActiveModel::VERSION::MAJOR
+      end
+
+      def self.action_pack_major_version
+        ::ActionPack::VERSION::MAJOR
       end
     end
   end

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '2.4.0'.freeze
+    VERSION = '2.5.0'.freeze
   end
 end

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

@@ -13,7 +13,7 @@ describe Shoulda::Matchers::ActionController::FilterParamMatcher do
 
     matcher.matches?(nil).should be_false
 
-    matcher.failure_message_for_should.should =~ /Expected other to be filtered.*secret/
+    matcher.failure_message.should =~ /Expected other to be filtered.*secret/
   end
 
   def filter(param)

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

@@ -18,7 +18,7 @@ describe Shoulda::Matchers::ActionController::RescueFromMatcher do
       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/
+        matcher.failure_message.should =~ /does not respond to/
       end
     end
 
@@ -35,7 +35,7 @@ describe Shoulda::Matchers::ActionController::RescueFromMatcher 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/
+      matcher.failure_message_when_negated.should =~ /Did not expect \w+ to rescue from/
     end
   end
 

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

@@ -54,6 +54,11 @@ describe Shoulda::Matchers::ActionController::RouteMatcher, type: :controller do
         to(:action => 'other', :id => '1')
     end
 
+    it "accepts a string as first parameter" do
+      route_examples_to_examples.should route(:get, '/examples/1').
+        to("examples#example", id: '1')
+    end
+
     def route_examples_to_examples
       define_routes do
         get 'examples/:id', :to => 'examples#example'

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RouteParams do
+  describe "#normalize" do
+    context "when the route parameters is a hash" do
+      it "stringifies the values in the hash" do
+        build_route_params(:controller => :examples, :action => 'example', :id => '1').normalize.
+          should eq({ :controller => "examples", :action => "example", :id => "1" })
+      end
+    end
+
+    context "when the route parameters is a string and a hash" do
+      it "produces a hash of route parameters" do
+        build_route_params("examples#example", id: '1').normalize.
+          should eq({ :controller => "examples", :action => "example", :id => "1" })
+      end
+    end
+
+    context "when the route params is a string" do
+      it "produces a hash of route params" do
+        build_route_params("examples#index").normalize.
+          should eq({ :controller => "examples", :action => "index"})
+      end
+    end
+  end
+
+  def build_route_params(*params)
+    Shoulda::Matchers::ActionController::RouteParams.new(params)
+  end
+end

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

@@ -70,7 +70,7 @@ describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
 
         matcher.matches?(no_protected_attributes).should be_true
 
-        matcher.failure_message_for_should_not.should_not be_nil
+        matcher.failure_message_when_negated.should_not be_nil
       end
     end
 

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

@@ -162,7 +162,7 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
 
         matcher.matches?(validating_format(:with => /abc/, :strict => true))
 
-        matcher.failure_message_for_should_not.should eq 'Expected exception to include /abc/ ' +
+        matcher.failure_message_when_negated.should eq 'Expected exception to include /abc/ ' +
           'when attr is set to "xyz", got Attr is invalid'
       end
     end

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

@@ -40,13 +40,13 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
     end
 
     it "delegates its failure message to its allow matcher's negative failure message" do
-      allow_matcher = stub_everything(:failure_message_for_should_not => 'allow matcher failure')
+      allow_matcher = stub_everything(:failure_message_when_negated => 'allow matcher failure')
       Shoulda::Matchers::ActiveModel::AllowValueMatcher.stubs(:new).returns(allow_matcher)
 
       matcher = matcher('abcde').for(:attr).with_message('good message')
       matcher.matches?(validating_format(:with => /abc/, :message => 'good message'))
 
-      matcher.failure_message_for_should.should eq 'allow matcher failure'
+      matcher.failure_message.should eq 'allow matcher failure'
     end
 
     it 'matches if the message is correct but the value is not' do

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

@@ -18,6 +18,16 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
     end
   end
 
+  context 'with an decimal column' do
+    it 'can verify decimal values' do
+      model = define_model(:example, :attr => :decimal) do
+        validates_inclusion_of :attr, :in => [0.0, 0.1]
+      end.new
+
+      model.should ensure_inclusion_of(:attr).in_array([0.0, 0.1])
+    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.