shoulda-matchers 2.6.0 → 2.6.1.rc1

data/lib/shoulda/matchers/doublespeak/object_double.rb

@@ -0,0 +1,32 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class ObjectDouble < BasicObject
+        attr_reader :calls
+
+        def initialize
+          @calls = []
+          @calls_by_method_name = {}
+        end
+
+        def calls_to(method_name)
+          @calls_by_method_name[method_name] || []
+        end
+
+        def respond_to?(name, include_private = nil)
+          true
+        end
+
+        def method_missing(method_name, *args, &block)
+          calls << MethodCallWithName.new(method_name, args, block)
+          (calls_by_method_name[method_name] ||= []) << MethodCall.new(args, block)
+          nil
+        end
+
+        private
+
+        attr_reader :calls_by_method_name
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/proxy_implementation.rb

@@ -0,0 +1,30 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class ProxyImplementation
+        extend Forwardable
+
+        DoubleImplementationRegistry.register(self, :proxy)
+
+        def_delegators :stub_implementation, :returns
+
+        def self.create
+          new(StubImplementation.new)
+        end
+
+        def initialize(stub_implementation)
+          @stub_implementation = stub_implementation
+        end
+
+        def call(double, object, args, block)
+          stub_implementation.call(double, object, args, block)
+          double.call_original_method(object, args, block)
+        end
+
+        private
+
+        attr_reader :stub_implementation
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/structs.rb

@@ -0,0 +1,8 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      MethodCall = Struct.new(:args, :block)
+      MethodCallWithName = Struct.new(:method_name, :args, :block)
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/stub_implementation.rb

@@ -0,0 +1,34 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class StubImplementation
+        DoubleImplementationRegistry.register(self, :stub)
+
+        def self.create
+          new
+        end
+
+        def initialize
+          @implementation = proc { nil }
+        end
+
+        def returns(value = nil, &block)
+          if block
+            @implementation = block
+          else
+            @implementation = proc { value }
+          end
+        end
+
+        def call(double, object, args, block)
+          double.record_call(args, block)
+          implementation.call(object, args, block)
+        end
+
+        private
+
+        attr_reader :implementation
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/world.rb

@@ -0,0 +1,38 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class World
+        def register_double_collection(klass)
+          double_collection = DoubleCollection.new(klass)
+          double_collections_by_class[klass] = double_collection
+          double_collection
+        end
+
+        def with_doubles_activated
+          activate
+          yield
+        ensure
+          deactivate
+        end
+
+        private
+
+        def activate
+          double_collections_by_class.each do |klass, double_collection|
+            double_collection.activate
+          end
+        end
+
+        def deactivate
+          double_collections_by_class.each do |klass, double_collection|
+            double_collection.deactivate
+          end
+        end
+
+        def double_collections_by_class
+          @_double_collections_by_class ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/independent/delegate_matcher.rb

@@ -5,19 +5,21 @@ module Shoulda # :nodoc:
       # Ensure that a given method is delegated properly.
       #
       # Basic Syntax:
-      #   it { should delegate_method(:deliver_mail).to(:mailman) }
+      #   it { should delegate_method(method_name).to(delegate_name) }
       #
       # Options:
-      # * <tt>:as</tt> - tests that the object being delegated to is called
-      #    with a certain method (defaults to same name as delegating method)
-      # * <tt>:with_arguments</tt> - tests that the method on the object being
-      #   delegated to is called with certain arguments
+      # * <tt>:as</tt> - The name of the delegating method. Defaults to
+      #   method_name.
+      # * <tt>:with_arguments</tt> - Tests that the delegate method is called
+      #   with certain arguments.
       #
       # Examples:
+      #   it { should delegate_method(:deliver_mail).to(:mailman) }
       #   it { should delegate_method(:deliver_mail).to(:mailman).
-      #     as(:deliver_with_haste) }
+      #     as(:deliver_mail_via_mailman) }
       #   it { should delegate_method(:deliver_mail).to(:mailman).
-      #     with_arguments('221B Baker St.', :hastily => true) }
+      #     as(:deliver_mail_hastily).
+      #     with_arguments('221B Baker St.', hastily: true) }
       #
       def delegate_method(delegating_method)
         DelegateMatcher.new(delegating_method)
@@ -26,20 +28,23 @@ module Shoulda # :nodoc:
       class DelegateMatcher
         def initialize(delegating_method)
           @delegating_method = delegating_method
+          @method_on_target = @delegating_method
+          @target_double = Doublespeak::ObjectDouble.new
+
           @delegated_arguments = []
+          @target_method = nil
+          @subject = nil
+          @subject_double_collection = nil
         end
 
-        def matches?(_subject)
-          @subject = _subject
+        def matches?(subject)
+          @subject = subject
+
           ensure_target_method_is_present!
-          stub_target
 
-          begin
-            subject.send(delegating_method, *delegated_arguments)
-            target_has_received_delegated_method? && target_has_received_arguments?
-          rescue NoMethodError
-            false
-          end
+          subject_has_delegating_method? &&
+            subject_has_target_method? &&
+            subject_delegates_to_target_correctly?
         end
 
         def description
@@ -48,10 +53,6 @@ module Shoulda # :nodoc:
           )
         end
 
-        def does_not_match?(subject)
-          raise InvalidDelegateMatcher
-        end
-
         def to(target_method)
           @target_method = target_method
           self
@@ -68,69 +69,77 @@ module Shoulda # :nodoc:
         end
 
         def failure_message
-          base = "Expected #{delegating_method_name} to delegate to #{target_method_name}"
+          base = "Expected #{formatted_delegating_method_name} to delegate to #{formatted_target_method_name}"
           add_clarifications_to(base)
+          base << "\nCalls on #{formatted_target_method_name}:"
+          base << formatted_calls_on_target
+          base.strip
         end
         alias failure_message_for_should failure_message
 
+        def failure_message_when_negated
+          base = "Expected #{formatted_delegating_method_name} not to delegate to #{formatted_target_method_name}"
+          add_clarifications_to(base)
+          base << ', but it did'
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
         private
 
-        attr_reader :delegated_arguments, :delegating_method, :method, :subject,
-          :target_method, :method_on_target
+        attr_reader \
+          :delegated_arguments,
+          :delegating_method,
+          :method,
+          :method_on_target,
+          :subject,
+          :subject_double_collection,
+          :target_double,
+          :target_method
 
         def add_clarifications_to(message)
-          if delegated_arguments.present?
+          if delegated_arguments.any?
             message << " with arguments: #{delegated_arguments.inspect}"
           end
 
-          if method_on_target.present?
+          if method_on_target != delegating_method
             message << " as ##{method_on_target}"
           end
 
           message
         end
 
-        def delegating_method_name
-          method_name_with_class(delegating_method)
+        def formatted_delegating_method_name
+          formatted_method_name_for(delegating_method)
         end
 
-        def target_method_name
-          method_name_with_class(target_method)
+        def formatted_target_method_name
+          formatted_method_name_for(target_method)
         end
 
-        def method_name_with_class(method)
-          if Class === subject
-            subject.name + '.' + method.to_s
+        def formatted_method_name_for(method_name)
+          if subject.is_a?(Class)
+            subject.name + '.' + method_name.to_s
           else
-            subject.class.name + '#' + method.to_s
+            subject.class.name + '#' + method_name.to_s
           end
         end
 
-        def target_has_received_delegated_method?
-          stubbed_target.has_received_method?
+        def target_received_method?
+          calls_to_method_on_target.any?
         end
 
-        def target_has_received_arguments?
-          stubbed_target.has_received_arguments?(*delegated_arguments)
+        def target_received_method_with_delegated_arguments?
+          calls_to_method_on_target.any? do |call|
+            call.args == delegated_arguments
+          end
         end
 
-        def stubbed_method
-          method_on_target || delegating_method
+        def subject_has_delegating_method?
+          subject.respond_to?(delegating_method)
         end
 
-        def stub_target
-          local_stubbed_target = stubbed_target
-          local_target_method = target_method
-
-          subject.instance_eval do
-            define_singleton_method local_target_method do
-              local_stubbed_target
-            end
-          end
-        end
-
-        def stubbed_target
-          @stubbed_target ||= StubbedTarget.new(stubbed_method)
+        def subject_has_target_method?
+          subject.respond_to?(target_method)
         end
 
         def ensure_target_method_is_present!
@@ -138,18 +147,60 @@ module Shoulda # :nodoc:
             raise TargetNotDefinedError
           end
         end
-      end
 
-      class DelegateMatcher::TargetNotDefinedError < StandardError
-        def message
-          'Delegation needs a target. Use the #to method to define one, e.g.
-          `post_office.should delegate(:deliver_mail).to(:mailman)`'.squish
+        def subject_delegates_to_target_correctly?
+          register_subject_double_collection
+
+          Doublespeak.with_doubles_activated do
+            subject.public_send(delegating_method, *delegated_arguments)
+          end
+
+          if delegated_arguments.any?
+            target_received_method_with_delegated_arguments?
+          else
+            target_received_method?
+          end
         end
-      end
 
-      class DelegateMatcher::InvalidDelegateMatcher < StandardError
-        def message
-          '#delegate_to does not support #should_not syntax.'
+        def register_subject_double_collection
+          double_collection =
+            Doublespeak.register_double_collection(subject.singleton_class)
+          double_collection.register_stub(target_method).
+            to_return(target_double)
+
+          @subject_double_collection = double_collection
+        end
+
+        def calls_to_method_on_target
+          target_double.calls_to(method_on_target)
+        end
+
+        def calls_on_target
+          target_double.calls
+        end
+
+        def formatted_calls_on_target
+          string = ""
+
+          if calls_on_target.any?
+            string << "\n"
+            calls_on_target.each_with_index do |call, i|
+              name = call.method_name
+              args = call.args.map { |arg| arg.inspect }.join(', ')
+              string << "#{i+1}) #{name}(#{args})\n"
+            end
+          else
+            string << " (none)"
+          end
+
+          string
+        end
+
+        class TargetNotDefinedError < StandardError
+          def message
+            'Delegation needs a target. Use the #to method to define one, e.g.
+            `post_office.should delegate(:deliver_mail).to(:mailman)`'.squish
+          end
         end
       end
     end

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

@@ -21,12 +21,14 @@ end
 
 if defined?(ActiveSupport::TestCase)
   ActiveSupport::TestCase.class_eval do
-    include Shoulda::Matchers::ActiveRecord
-    extend Shoulda::Matchers::ActiveRecord
-  end
+    if defined?(Shoulda::Matchers::ActiveRecord)
+      include Shoulda::Matchers::ActiveRecord
+      extend Shoulda::Matchers::ActiveRecord
+    end
 
-  ActiveSupport::TestCase.class_eval do
-    include Shoulda::Matchers::ActiveModel
-    extend Shoulda::Matchers::ActiveModel
+    if defined?(Shoulda::Matchers::ActiveModel)
+      include Shoulda::Matchers::ActiveModel
+      extend Shoulda::Matchers::ActiveModel
+    end
   end
 end

data/lib/shoulda/matchers/rails_shim.rb

@@ -33,6 +33,14 @@ module Shoulda # :nodoc:
         end
       end
 
+      def self.verb_for_update
+        if action_pack_gte_4_1?
+          :patch
+        else
+          :put
+        end
+      end
+
       def self.active_record_major_version
         ::ActiveRecord::VERSION::MAJOR
       end
@@ -44,6 +52,14 @@ module Shoulda # :nodoc:
       def self.action_pack_major_version
         ::ActionPack::VERSION::MAJOR
       end
+
+      def self.action_pack_gte_4_1?
+        Gem::Requirement.new('>= 4.1').satisfied_by?(action_pack_version)
+      end
+
+      def self.action_pack_version
+        Gem::Version.new(::ActionPack::VERSION::STRING)
+      end
     end
   end
 end