shoulda-matchers 2.3.0 → 2.4.0.rc1

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

@@ -0,0 +1,93 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        class OptionVerifier
+          delegate :reflection, to: :reflector
+
+          attr_reader :reflector
+
+          RELATION_OPTIONS = [:conditions, :order]
+
+          def initialize(reflector)
+            @reflector = reflector
+          end
+
+          def correct_for_string?(name, expected_value)
+            correct_for?(:string, name, expected_value)
+          end
+
+          def correct_for_boolean?(name, expected_value)
+            correct_for?(:boolean, name, expected_value)
+          end
+
+          def correct_for_hash?(name, expected_value)
+            correct_for?(:hash, name, expected_value)
+          end
+
+          def correct_for_relation_clause?(name, expected_value)
+            correct_for?(:relation_clause, name, expected_value)
+          end
+
+          def actual_value_for(name)
+            if RELATION_OPTIONS.include?(name)
+              actual_value_for_relation_clause(name)
+            else
+              method_name = "actual_value_for_#{name}"
+              if respond_to?(method_name, true)
+                __send__(method_name)
+              else
+                reflection.options[name]
+              end
+            end
+          end
+
+          private
+
+          attr_reader :reflector
+
+          def correct_for?(*args)
+            expected_value, name, type = args.reverse
+            if expected_value.nil?
+              true
+            else
+              expected_value = type_cast(type, expected_value_for(name, expected_value))
+              actual_value = type_cast(type, actual_value_for(name))
+              expected_value == actual_value
+            end
+          end
+
+          def type_cast(type, value)
+            case type
+              when :string, :relation_clause then value.to_s
+              when :boolean                  then !!value
+              when :hash                     then Hash(value).stringify_keys
+              else                                value
+            end
+          end
+
+          def expected_value_for(name, value)
+            if RELATION_OPTIONS.include?(name)
+              expected_value_for_relation_clause(name, value)
+            else
+              value
+            end
+          end
+
+          def expected_value_for_relation_clause(name, value)
+            relation = reflector.build_relation_with_clause(name, value)
+            reflector.extract_relation_clause_from(relation, name)
+          end
+
+          def actual_value_for_relation_clause(name)
+            reflector.extract_relation_clause_from(reflector.association_relation, name)
+          end
+
+          def actual_value_for_class_name
+            reflector.associated_class
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,9 +16,9 @@ module Shoulda # :nodoc:
           end
 
           def matches?(subject)
-            subject = ModelReflector.new(subject, name)
+            self.subject = ModelReflector.new(subject, name)
 
-            if subject.option_set_properly?(order, :order)
+            if option_verifier.correct_for_relation_clause?(:order, order)
               true
             else
               self.missing_option = "#{name} should be ordered by #{order}"
@@ -27,7 +27,12 @@ module Shoulda # :nodoc:
           end
 
           private
-          attr_accessor :order, :name
+
+          attr_accessor :subject, :order, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
         end
       end
     end

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

@@ -38,18 +38,23 @@ module Shoulda # :nodoc:
           end
 
           def through_association_correct?
-            if subject.option_set_properly?(through, :through)
+            if option_verifier.correct_for_string?(:through, through)
               true
             else
               self.missing_option =
                 "Expected #{name} to have #{name} through #{through}, " +
-                "but got it through #{subject.option_string(:through)}"
+                "but got it through #{option_verifier.actual_value_for(:through)}"
               false
             end
           end
 
           private
+
           attr_accessor :through, :name, :subject
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
         end
       end
     end

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

@@ -1,10 +1,7 @@
-# :enddoc:
-require 'test/unit/testcase'
-
 if defined?(ActionController)
   require 'shoulda/matchers/action_controller'
 
-  class ActionController::TestCase
+  ActionController::TestCase.class_eval do
     include Shoulda::Matchers::ActionController
     extend Shoulda::Matchers::ActionController
 
@@ -16,27 +13,18 @@ end
 
 if defined?(ActiveRecord)
   require 'shoulda/matchers/active_record'
-  require 'shoulda/matchers/active_model'
 
-  module Test
-    module Unit
-      class TestCase
-        include Shoulda::Matchers::ActiveRecord
-        extend Shoulda::Matchers::ActiveRecord
-        include Shoulda::Matchers::ActiveModel
-        extend Shoulda::Matchers::ActiveModel
-      end
-    end
+  ActiveSupport::TestCase.class_eval do
+    include Shoulda::Matchers::ActiveRecord
+    extend Shoulda::Matchers::ActiveRecord
   end
-elsif defined?(ActiveModel)
+end
+
+if defined?(ActiveModel)
   require 'shoulda/matchers/active_model'
 
-  module Test
-    module Unit
-      class TestCase
-        include Shoulda::Matchers::ActiveModel
-        extend Shoulda::Matchers::ActiveModel
-      end
-    end
+  ActiveSupport::TestCase.class_eval do
+    include Shoulda::Matchers::ActiveModel
+    extend Shoulda::Matchers::ActiveModel
   end
 end

data/lib/shoulda/matchers/rails_shim.rb

@@ -0,0 +1,41 @@
+module Shoulda # :nodoc:
+  module Matchers
+    class RailsShim # :nodoc:
+      def self.layouts_ivar
+        if rails_major_version >= 4
+          '@_layouts'
+        else
+          '@layouts'
+        end
+      end
+
+      def self.flashes_ivar
+        if rails_major_version >= 4
+          :@flashes
+        else
+          :@used
+        end
+      end
+
+      def self.clean_scope(klass)
+        if rails_major_version == 4
+          klass.all
+        else
+          klass.scoped
+        end
+      end
+
+      def self.validates_confirmation_of_error_attribute(matcher)
+        if rails_major_version == 4
+          matcher.confirmation_attribute
+        else
+          matcher.attribute
+        end
+      end
+
+      def self.rails_major_version
+        Rails::VERSION::MAJOR
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/version.rb

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

data/shoulda-matchers.gemspec

@@ -28,6 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency('cucumber',    '~> 1.1')
   s.add_development_dependency('rails',       '~> 3.0')
   s.add_development_dependency('rake',        '>= 0.9.2')
-  s.add_development_dependency('rspec-rails', '~> 2.13')
-  s.add_development_dependency('strong_parameters')
+  s.add_development_dependency('rspec-rails', '>= 2.13.1', '< 3')
 end

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

@@ -47,8 +47,13 @@ describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
     end
 
     def set_in_context_layout(layout)
-      @layouts = Hash.new(0)
-      @layouts[layout] = 1
+      layouts = Hash.new(0)
+      layouts[layout] = 1
+      self.instance_variable_set(layouts_ivar, layouts)
+    end
+
+    def layouts_ivar
+      Shoulda::Matchers::RailsShim.layouts_ivar
     end
 
     def controller_without_layout

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActionController::RouteMatcher do
+describe Shoulda::Matchers::ActionController::RouteMatcher, type: :controller do
   context 'given a controller with a defined glob url' do
     it 'accepts glob route' do
       controller = define_controller('Examples').new
 
       define_routes do
-        match 'examples/*id', :to => 'examples#example'
+        get 'examples/*id', :to => 'examples#example'
       end
 
       controller.should route(:get, '/examples/foo/bar').

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

@@ -59,7 +59,7 @@ describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher do
     end
   end
 
-  unless active_model_3_2?
+  unless active_model_3_2? || active_model_4_0?
     context 'an attribute on a class with no protected attributes' do
       it 'accepts being mass-assignable' do
         no_protected_attributes.should allow_mass_assignment_of(:attr)

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

@@ -56,6 +56,30 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
     end
   end
 
+  context 'an attribute where the message occurs on another attribute' do
+    it 'allows a good value' do
+      record_with_custom_validation.should \
+        allow_value('good value').for(:attr).with_message(/some message/, :against => :attr2)
+    end
+
+    it 'rejects a bad value' do
+      record_with_custom_validation.should_not \
+        allow_value('bad value').for(:attr).with_message(/some message/, :against => :attr2)
+    end
+
+    def record_with_custom_validation
+      define_model :example, :attr => :string, :attr2 => :string do
+        validate :custom_validation
+
+        def custom_validation
+          if self[:attr] != 'good value'
+            self.errors[:attr2] << 'some message'
+          end
+        end
+      end.new
+    end
+  end
+
   context "an attribute with a context-dependent validation" do
     context "without the validation context" do
       it "allows a bad value" do

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

@@ -55,6 +55,30 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher do
     end
   end
 
+  context 'an attribute where the message occurs on another attribute' do
+    it 'matches if the message is correct but the value is not' do
+      record_with_custom_validation.should \
+        matcher('bad value').for(:attr).with_message(/some message/, :against => :attr2)
+    end
+
+    it 'does not match if the value and message are both correct' do
+      record_with_custom_validation.should_not \
+        matcher('good value').for(:attr).with_message(/some message/, :against => :attr2)
+    end
+
+    def record_with_custom_validation
+      define_model :example, :attr => :string, :attr2 => :string do
+        validate :custom_validation
+
+        def custom_validation
+          if self[:attr] != 'good value'
+            self.errors[:attr2] << 'some message'
+          end
+        end
+      end.new
+    end
+  end
+
   def matcher(value)
     described_class.new(value)
   end

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

@@ -78,13 +78,11 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
       end
     end
 
-    if active_model_3_0?
-      context 'if ActiveModel::Errors#generate_message behavior has changed' do
-        it 'provides the right error message for validate_presence_of' do
-          stub_active_model_message_generation(:type => :blank,
-                                               :message => 'Behavior has diverged.')
-          assert_presence_validation_has_correct_message
-        end
+    context 'if ActiveModel::Errors#generate_message behavior has changed' do
+      it 'provides the right error message for validate_presence_of' do
+        stub_active_model_message_generation(:type => :blank,
+                                              :message => 'Behavior has diverged.')
+        assert_presence_validation_has_correct_message
       end
     end
   end

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

@@ -67,8 +67,8 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     it 'accepts an association with a valid :conditions option' do
       define_model :parent, :adopter => :boolean
-      define_model :child, :parent_id => :integer do
-        belongs_to :parent, :conditions => { :adopter => true }
+      define_model(:child, :parent_id => :integer).tap do |model|
+        define_association_with_conditions(model, :belongs_to, :parent, :adopter => true)
       end
 
       Child.new.should belong_to(:parent).conditions(:adopter => true)
@@ -297,8 +297,8 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     it 'accepts an association with a valid :conditions option' do
       define_model :child, :parent_id => :integer, :adopted => :boolean
-      define_model :parent do
-        has_many :children, :conditions => { :adopted => true }
+      define_model(:parent).tap do |model|
+        define_association_with_conditions(model, :has_many, :children, :adopted => true)
       end
 
       Parent.new.should have_many(:children).conditions(:adopted => true)
@@ -374,8 +374,13 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     def having_many_children(options = {})
       define_model :child, :parent_id => :integer
-      define_model :parent do
-        has_many :children, options
+      define_model(:parent).tap do |model|
+        if options.key?(:order)
+          order = options.delete(:order)
+          define_association_with_order(model, :has_many, :children, order, options)
+        else
+          model.has_many :children, options
+        end
       end.new
     end
   end
@@ -449,8 +454,8 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     it 'accepts an association with a valid :conditions option' do
       define_model :detail, :person_id => :integer, :disabled => :boolean
-      define_model :person do
-        has_one :detail, :conditions => { :disabled => true}
+      define_model(:person).tap do |model|
+        define_association_with_conditions(model, :has_one, :detail, :disabled => true)
       end
 
       Person.new.should have_one(:detail).conditions(:disabled => true)
@@ -524,8 +529,13 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     def having_one_detail(options = {})
       define_model :detail, :person_id => :integer
-      define_model :person do
-        has_one :detail, options
+      define_model(:person).tap do |model|
+        if options.key?(:order)
+          order = options.delete(:order)
+          define_association_with_order(model, :has_one, :detail, order, options)
+        else
+          model.has_one :detail, options
+        end
       end.new
     end
   end
@@ -565,8 +575,8 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
 
     it 'accepts an association with a valid :conditions option' do
       define_model :relative, :adopted => :boolean
-      define_model :person do
-        has_and_belongs_to_many :relatives, :conditions => { :adopted => true }
+      define_model(:person).tap do |model|
+        define_association_with_conditions(model, :has_and_belongs_to_many, :relatives, :adopted => true)
       end
       define_model :people_relative, :id => false, :person_id => :integer,
         :relative_id => :integer
@@ -638,4 +648,28 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher do
       end.new
     end
   end
+
+  def define_association_with_conditions(model, macro, name, conditions, other_options={})
+    args = []
+    options = {}
+    if Shoulda::Matchers::RailsShim.rails_major_version == 4
+      args << lambda { where(conditions) }
+    else
+      options[:conditions] = conditions
+    end
+    args << options
+    model.__send__(macro, name, *args)
+  end
+
+  def define_association_with_order(model, macro, name, order, other_options={})
+    args = []
+    options = {}
+    if Shoulda::Matchers::RailsShim.rails_major_version == 4
+      args << lambda { order(order) }
+    else
+      options[:order] = order
+    end
+    args << options
+    model.__send__(macro, name, *args)
+  end
 end