rr 0.6.0 → 0.7.0

data/lib/rr/double_definitions/child_double_definition_creator.rb

@@ -7,6 +7,10 @@ module RR
         super()
       end
 
+      def root_subject
+        parent_double_definition.root_subject
+      end
+
       def instance_of(*args)
         raise NoMethodError
       end

data/lib/rr/double_definitions/double_definition.rb

@@ -40,67 +40,148 @@ module RR
         @double_definition_creator = double_definition_creator
         @subject = subject
       end
+      
+      attr_reader :argument_expectation
 
-      module DefinitionConstructionMethods
+      def root_subject
+        double_definition_creator.root_subject
+      end
+      
+      module ArgumentDefinitionConstructionMethods
+        # Double#with sets the expectation that the Double will receive
+        # the passed in arguments.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.with(1, 2) {:return_value}        
         def with(*args, &return_value_block)
           @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
           install_method_callback return_value_block
           self
         end
 
+        # Double#with_any_args sets the expectation that the Double can receive
+        # any arguments.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.with_any_args {:return_value}
         def with_any_args(&return_value_block)
           @argument_expectation = Expectations::AnyArgumentExpectation.new
           install_method_callback return_value_block
           self
         end
 
+        # Double#with_no_args sets the expectation that the Double will receive
+        # no arguments.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.with_no_args {:return_value}
         def with_no_args(&return_value_block)
           @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
           install_method_callback return_value_block
           self
-        end
+        end        
+      end
+      include ArgumentDefinitionConstructionMethods
 
+      module TimesDefinitionConstructionMethods
+        # Double#never sets the expectation that the Double will never be
+        # called.
+        #
+        # This method does not accept a block because it will never be called.
+        #
+        #   mock(subject).method_name.never
         def never
           @times_matcher = TimesCalledMatchers::IntegerMatcher.new(0)
           self
         end
 
+        # Double#once sets the expectation that the Double will be called
+        # 1 time.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.once {:return_value}
         def once(&return_value_block)
           @times_matcher = TimesCalledMatchers::IntegerMatcher.new(1)
           install_method_callback return_value_block
           self
         end
 
+        # Double#twice sets the expectation that the Double will be called
+        # 2 times.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.twice {:return_value}        
         def twice(&return_value_block)
           @times_matcher = TimesCalledMatchers::IntegerMatcher.new(2)
           install_method_callback return_value_block
           self
         end
 
+        # Double#at_least sets the expectation that the Double
+        # will be called at least n times.
+        # It works by creating a TimesCalledExpectation.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.at_least(4) {:return_value}
         def at_least(number, &return_value_block)
           @times_matcher = TimesCalledMatchers::AtLeastMatcher.new(number)
           install_method_callback return_value_block
           self
         end
 
+        # Double#at_most allows sets the expectation that the Double
+        # will be called at most n times.
+        # It works by creating a TimesCalledExpectation.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.at_most(4) {:return_value}        
         def at_most(number, &return_value_block)
           @times_matcher = TimesCalledMatchers::AtMostMatcher.new(number)
           install_method_callback return_value_block
           self
         end
 
+        # Double#any_number_of_times sets an that the Double will be called
+        # any number of times. This effectively removes the times called expectation
+        # from the Doublen
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.any_number_of_times        
         def any_number_of_times(&return_value_block)
           @times_matcher = TimesCalledMatchers::AnyTimesMatcher.new
           install_method_callback return_value_block
           self
         end
 
+        # Double#times creates an TimesCalledExpectation of the passed
+        # in number.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.times(4) {:return_value}        
         def times(matcher_value, &return_value_block)
           @times_matcher = TimesCalledMatchers::TimesCalledMatcher.create(matcher_value)
           install_method_callback return_value_block
           self
         end
+      end
+      include TimesDefinitionConstructionMethods
 
+      module DefinitionConstructionMethods
+        # Double#ordered sets the Double to have an ordered
+        # expectation.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.ordered {return_value}
         def ordered(&return_value_block)
           raise(
             Errors::DoubleDefinitionError,
@@ -115,24 +196,53 @@ module RR
         end
         alias_method :then, :ordered
 
+        # Double#yields sets the Double to invoke a passed in block when
+        # the Double is called.
+        # An Expection will be raised if no block is passed in when the
+        # Double is called.
+        #
+        # Passing in a block sets the return value.
+        #
+        #   mock(subject).method_name.yields(yield_arg1, yield_arg2) {return_value}
+        #   subject.method_name {|yield_arg1, yield_arg2|}
         def yields(*args, &return_value_block)
           @yields_value = args
           install_method_callback return_value_block
           self
         end
 
+        # Double#after_call creates a callback that occurs after call
+        # is called. The passed in block receives the return value of
+        # the Double being called.
+        # An Expection will be raised if no block is passed in.
+        #
+        #   mock(subject).method_name {return_value}.after_call {|return_value|}
+        #   subject.method_name # return_value
+        #
+        # This feature is built into proxies.
+        #   mock.proxy(User).find('1') {|user| mock(user).valid? {false}}
         def after_call(&after_call_proc)
           raise ArgumentError, "after_call expects a block" unless after_call_proc
           @after_call_proc = after_call_proc
           self
         end
 
+        # Double#verbose sets the Double to print out each method call it receives.
+        #
+        # Passing in a block sets the return value
         def verbose(&after_call_proc)
           @verbose = true
           @after_call_proc = after_call_proc
           self
         end
 
+        # Double#returns accepts an argument value or a block.
+        # It will raise an ArgumentError if both are passed in.
+        #
+        # Passing in a block causes Double to return the return value of
+        # the passed in block.
+        #
+        # Passing in an argument causes Double to return the argument.
         def returns(*args, &implementation)
           value = args.first
           if !args.empty? && implementation
@@ -151,11 +261,26 @@ module RR
           self
         end
 
+        # Double#implemented_by sets the implementation of the Double.
+        # This method takes a Proc or a Method. Passing in a Method allows
+        # the Double to accept blocks.
+        #
+        #   obj = Object.new
+        #   def obj.foobar
+        #     yield(1)
+        #   end
+        #   mock(obj).method_name.implemented_by(obj.method(:foobar))
         def implemented_by(implementation)
           @implementation = implementation
           self
         end
 
+        def verify_method_signature
+          @verify_method_signature = true
+          self
+        end
+        alias_method :strong, :verify_method_signature
+        
         protected
         def install_method_callback(block)
           return unless block
@@ -169,10 +294,15 @@ module RR
       include DefinitionConstructionMethods
 
       module StateQueryMethods
+        # Double#ordered? returns true when the Double is ordered.
+        #
+        #   mock(subject).method_name.ordered?
         def ordered?
           @ordered
         end
 
+        # Double#verbose? returns true when verbose has been called on it. It returns
+        # true when the double is set to print each method call it receives.
         def verbose?
           @verbose ? true : false
         end
@@ -193,14 +323,18 @@ module RR
         end
 
         def expected_arguments
-          return [] unless argument_expectation
-          argument_expectation.expected_arguments
+          argument_expectation ? argument_expectation.expected_arguments : []
         end
 
         def implementation_is_original_method?
           implementation_strategy.is_a?(Strategies::Implementation::Proxy)
         end
 
+        def verify_method_signature?
+          !!@verify_method_signature
+        end
+        alias_method :strong?, :verify_method_signature?        
+
         protected
         def implementation_strategy
           double_definition_creator.implementation_strategy

data/lib/rr/double_definitions/double_definition_creator.rb

@@ -17,7 +17,7 @@ module RR
           end
           CLASS
         end
-
+        
         def register_implementation_strategy_class(strategy_class, method_name)
           class_eval((<<-CLASS), __FILE__, __LINE__ + 1)
           def #{method_name}(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
@@ -51,7 +51,13 @@ module RR
         end
       end
 
-      attr_reader :subject, :method_name, :args, :handler, :definition, :verification_strategy, :implementation_strategy, :scope_strategy
+      attr_reader :subject, 
+                  :method_name, 
+                  :args, :handler, 
+                  :definition, 
+                  :verification_strategy, 
+                  :implementation_strategy, 
+                  :scope_strategy
       NO_SUBJECT = Object.new
 
       include Space::Reader
@@ -62,6 +68,14 @@ module RR
         @scope_strategy = Strategies::Scope::Instance.new(self)
       end
 
+      def root_subject
+        subject
+      end      
+      
+      def method_name
+        @verification_strategy.method_name
+      end
+      
       module StrategySetupMethods
         def no_subject?
           subject.__id__ === NO_SUBJECT.__id__
@@ -89,7 +103,7 @@ module RR
           @verification_strategy = verification_strategy
           verification_strategy
         end
-
+        
         def implementation_strategy=(implementation_strategy)
           verify_not_proxy_and_dont_allow(verification_strategy, implementation_strategy)
           @implementation_strategy = implementation_strategy
@@ -150,4 +164,4 @@ module RR
       end
     end
   end
-end
+end

data/lib/rr/double_definitions/double_definition_creator_proxy.rb

@@ -4,17 +4,49 @@ module RR
       def initialize(creator, &block) #:nodoc:
         @creator = creator
         class << self
+          def __apply_blank_slate
+            @apply_blank_slate = true
+          end
+
+          def __apply_blank_slate?
+            @apply_blank_slate ||= false
+          end
+
           instance_methods.each do |m|
-            unless m =~ /^_/ || m.to_s == 'object_id'
+            unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == "instance_eval" || m.to_s == 'respond_to?'
+              alias_method "__blank_slated_#{m}", m
               undef_method m
             end
           end
 
+          def instance_eval
+            return_value = super
+            class << self
+              alias_method "__blank_slated_instance_eval", "instance_eval"
+              undef_method :instance_eval
+              alias_method "__blank_slated_respond_to?", "respond_to?"
+              undef_method :respond_to?
+            end
+            return_value
+          end
+
           def method_missing(method_name, *args, &block)
-            @creator.create(method_name, *args, &block)
+            if __apply_blank_slate?
+              @creator.create(method_name, *args, &block)
+            else
+              __blank_slated_send("__blank_slated_#{method_name}", *args, &block)
+            end
+          end
+        end
+
+        __apply_blank_slate
+        if block_given?
+          if block.arity == 1
+            yield(self)
+          else
+            instance_eval(&block)
           end
         end
-        yield(self) if block_given?
       end
 
       def __creator__

data/lib/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation.rb

@@ -0,0 +1,17 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Implementation
+        class StronglyTypedReimplementation < Reimplementation
+          register("strong")
+
+          protected
+          def do_call
+            super
+            definition.verify_method_signature
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rr/double_definitions/strategies/scope/instance_of_class.rb

@@ -27,12 +27,15 @@ module RR
           protected
           def do_call
             class_handler = lambda do |return_value|
+              #####
               double_injection = space.double_injection(return_value, method_name)
               Double.new(double_injection, definition)
+              #####
               return_value
             end
 
             instance_of_subject_creator = DoubleDefinitionCreator.new
+            instance_of_subject_creator.strong if definition.verify_method_signature?
             instance_of_subject_creator.stub.proxy(subject)
             instance_of_subject_creator.create(:new, &class_handler)
           end

data/lib/rr/double_injection.rb

@@ -3,6 +3,7 @@ module RR
   # A double_injection has 0 to many Double objects. Each Double
   # has Argument Expectations and Times called Expectations.
   class DoubleInjection
+    include Space::Reader
     MethodArguments = Struct.new(:arguments, :block)
     attr_reader :subject, :method_name, :doubles
 
@@ -38,6 +39,7 @@ module RR
         end
       METHOD
       meta.class_eval(returns_method, __FILE__, __LINE__ - 5)
+      self
     end
 
     # RR::DoubleInjection#verify verifies each Double
@@ -78,6 +80,7 @@ module RR
     end
 
     def call_method(args, block)
+      space.record_call(subject, method_name, args, block)
       if double = find_double_to_attempt(args)
         double.call(self, *args, &block)
       else
@@ -112,11 +115,12 @@ module RR
     end
 
     def double_not_found_error(*args)
-      message = "On subject #{subject},\n"
-      message << "unexpected method invocation:\n"
-      message << "  #{Double.formatted_name(@method_name, args)}\n"
-      message << "expected invocations:\n"
-      message << Double.list_message_part(@doubles)
+      message =
+        "On subject #{subject},\n" <<
+        "unexpected method invocation:\n" <<
+        "  #{Double.formatted_name(@method_name, args)}\n" <<
+        "expected invocations:\n" <<
+        Double.list_message_part(@doubles)
       raise Errors::DoubleNotFoundError, message
     end
 
@@ -136,4 +140,4 @@ module RR
       (class << @subject; self; end)
     end
   end
-end
+end