rr 0.6.0 → 0.7.0

data/CHANGES

@@ -1,3 +1,13 @@
+* 0.7.0
+- Added spies (Patchs by Joe Ferris, Michael Niessner & Mike Mangino)
+- Added strongly typed reimplementation doubles (Patch by Michael Niessner)
+
+* 0.6.2
+- Fixed DoubleDefinition chaining edge cases
+
+* 0.6.1
+- DoubleDefinitionCreatorProxy definition eval block is instance_evaled when the arity is not 1. When the arity is 1, the block is yielded with the DoubleDefinitionCreatorProxy passed in.
+ 
 * 0.6.0
 - Friendlier DoubleNotFound error message
 - Implemented Double strategy creation methods (#mock, #stub, #proxy, #instance_of, and ! equivalents) on DoubleDefinition

data/README.rdoc

@@ -23,8 +23,7 @@ double for tests. The following are test doubles:
 * Proxies
 http://xunitpatterns.com/Test%20Double.html
 
-Currently RR implements mocks, stubs, and proxies. In the future, RR will
-support spies.
+Currently RR implements mocks, stubs, proxies, and spies. Fakes usually require custom code, so it is beyond the scope of RR.
 
 == Using RR
 === test/unit
@@ -202,14 +201,50 @@ Put double scenarios on instances of a Class.
 
   mock.instance_of(User).valid? {false}
 
+=== Spies
+
+Adding a DoubleInjection to an Object + Method (done by stub, mock, or dont_allow) causes RR to record any method
+invocations to the Object + method. Assertions can then be made on the recorded method calls.
+
+==== test/unit
+
+  subject = Object.new
+  stub(subject).foo
+  subject.foo(1)
+  assert_received(subject) {|subject| subject.foo(1)}
+  assert_received(subject) {|subject| subject.bar} # This fails
+
+==== rspec
+
+  subject = Object.new
+  stub(subject).foo
+  subject.foo(1)
+  subject.should have_received.foo(1)
+  subject.should have_received.bar # this fails
+
 === Block Syntax
+The block syntax has two modes
+* A normal block mode with a DoubleDefinitionCreatorProxy argument
+
   script = MyScript.new
-  mock(script) do |m|
-    m.system("cd #{RAILS_ENV}") {true}
-    m.system("rake foo:bar") {true}
-    m.system("rake baz") {true}
+  mock(script) do |expect|
+    expect.system("cd #{RAILS_ENV}") {true}
+    expect.system("rake foo:bar") {true}
+    expect.system("rake baz") {true}
   end
 
+* An instance_eval mode where the DoubleDefinitionCreatorProxy is instance_evaled
+
+    script = MyScript.new
+    mock(script) do
+      system("cd #{RAILS_ENV}") {true}
+      system("rake foo:bar") {true}
+      system("rake baz") {true}
+    end
+
+=== Block Syntax with explicit DoubleDefinitionCreatorProxy argument
+
+
 === Double Graphs
 RR has a method-chaining api support for Double graphs. For example,
 lets say you want an object to receive a method call to #foo, and have
@@ -273,19 +308,22 @@ In RR, you would do:
 == Special Thanks To
 With any development effort, there are countless people who have contributed
 to making it possible. We all are standing on the shoulders of giants.
-* Pivotal Labs for sponsoring RR development
-* Nick Kallen for documentation suggestions, bug reports, and patches
-* Matthew O'Conner for patches
-* Nathan Sobo for various ideas and inspiration for cleaner and more expressive code
-* Parker Thompson for pairing with me
+* Aslak Hellesoy for Developing Rspec
+* Dan North for syntax ideas
+* Dave Astels for some BDD inspiration
+* David Chelimsky for encouragement to make the RR framework, for developing the Rspec mock framework, and syntax ideas
 * Felix Morio for pairing with me
-* Jeff Whitmire for documentation suggestions
-* David Chelimsky for encouragement to make the RR framework, for developing
-  the Rspec mock framework, and syntax ideas
 * Gerard Meszaros for his excellent book "xUnit Test Patterns"
-* Dan North for syntax ideas
-* Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby
 * James Mead for developing Mocha
-* Aslak Hellesoy for Developing Rspec
+* Joe Ferris for patches
+* Jeff Whitmire for documentation suggestions
+* Jim Weirich for developing Flexmock, the first Terse ruby mock framework in Ruby
+* Joe Ferris for patches
+* Matthew O'Conner for patches
+* Michael Niessner for patches and pairing with me
+* Mike Mangino (from Elevated Rails) for patches and pairing with me
+* Nick Kallen for documentation suggestions, bug reports, and patches
+* Nathan Sobo for various ideas and inspiration for cleaner and more expressive code
+* Parker Thompson for pairing with me
+* Pivotal Labs for sponsoring RR development
 * Stephen Baker for Developing Rspec
-* Dave Astels for some BDD inspiration

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "rr"
-PKG_VERSION = "0.6.0"
+PKG_VERSION = "0.7.0"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',
@@ -52,7 +52,6 @@ spec = Gem::Specification.new do |s|
 
   s.test_files = Dir.glob('spec/*_spec.rb')
   s.require_path = 'lib'
-  s.autorequire = 'rr'
   s.author = "Brian Takita"
   s.email = "brian@pivotallabs.com"
   s.homepage = "http://pivotallabs.com"

data/lib/rr.rb

@@ -1,14 +1,22 @@
 dir = File.dirname(__FILE__)
+require 'rubygems'
+
 require "#{dir}/rr/errors/rr_error"
+require "#{dir}/rr/errors/subject_does_not_implement_method_error"
+require "#{dir}/rr/errors/subject_has_different_arity_error"
 require "#{dir}/rr/errors/double_definition_error"
 require "#{dir}/rr/errors/double_not_found_error"
 require "#{dir}/rr/errors/double_order_error"
 require "#{dir}/rr/errors/argument_equality_error"
 require "#{dir}/rr/errors/times_called_error"
+require "#{dir}/rr/errors/spy_verification_errors/spy_verification_error"
+require "#{dir}/rr/errors/spy_verification_errors/double_injection_not_found_error"
+require "#{dir}/rr/errors/spy_verification_errors/invocation_count_error"
 
 require "#{dir}/rr/space"
 require "#{dir}/rr/double_injection"
 require "#{dir}/rr/hash_with_object_id_key"
+require "#{dir}/rr/recorded_calls"
 
 require "#{dir}/rr/double_definitions/double_definition_creator_proxy"
 require "#{dir}/rr/double_definitions/double_definition_creator"
@@ -24,6 +32,7 @@ require "#{dir}/rr/double_definitions/strategies/verification/stub"
 require "#{dir}/rr/double_definitions/strategies/verification/dont_allow"
 require "#{dir}/rr/double_definitions/strategies/implementation/implementation_strategy"
 require "#{dir}/rr/double_definitions/strategies/implementation/reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation"
 require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
 require "#{dir}/rr/double_definitions/strategies/scope/scope_strategy"
 require "#{dir}/rr/double_definitions/strategies/scope/instance"
@@ -54,11 +63,15 @@ require "#{dir}/rr/times_called_matchers/proc_matcher"
 require "#{dir}/rr/times_called_matchers/at_least_matcher"
 require "#{dir}/rr/times_called_matchers/at_most_matcher"
 
+require "#{dir}/rr/spy_verification_proxy"
+require "#{dir}/rr/spy_verification"
+
 require "#{dir}/rr/adapters/rspec"
 require "#{dir}/rr/adapters/test_unit"
 
 module RR
   class << self
+    include Adapters::RRMethods
     (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
       returns_method = <<-METHOD
         def #{method_name}(*args, &block)
@@ -67,9 +80,5 @@ module RR
       METHOD
       class_eval(returns_method, __FILE__, __LINE__ - 4)
     end
-
-    def method_missing(method_name, *args, &block)
-      RR::Space.instance.__send__(method_name, *args, &block)
-    end
   end
-end
+end

data/lib/rr/adapters/rr_methods.rb

@@ -99,7 +99,18 @@ module RR
         expectation_proc ||= block
         RR::WildcardMatchers::Satisfy.new(expectation_proc)
       end
+      
+      def spy(subject)
+        methods_to_stub = subject.public_methods - ["methods", "==", "__send__", "__id__"]
+        methods_to_stub.each do |method|
+          stub.proxy(subject, method)
+        end
+      end
 
+      def received(subject)
+        RR::SpyVerificationProxy.new(subject)
+      end
+      
       instance_methods.each do |name|
         alias_method "rr_#{name}", name
       end

data/lib/rr/adapters/rspec.rb

@@ -18,6 +18,36 @@ module RR
       def teardown_mocks_for_rspec
         RR.reset
       end
+
+      def have_received(method = nil)
+        InvocationMatcher.new(method)
+      end
+
+      class InvocationMatcher < SpyVerificationProxy
+        attr_reader :failure_message
+ 
+        def initialize(method = nil)
+          method_missing(method) if method
+        end
+
+        def matches?(subject)
+          @verification.subject = subject
+          RR::Space.instance.recorded_calls.match_error(@verification) ? false : true
+        end
+
+        def nil?
+          false
+        end
+
+        def method_missing(method_name, *args, &block)
+          if @verification
+            @verification.send(method_name, *args)
+          else
+            @verification = super
+          end
+          self
+        end
+      end
     end
   end
 end

data/lib/rr/adapters/test_unit.rb

@@ -20,6 +20,10 @@ module RR
           alias_method :teardown, :teardown_with_rr
         end
       end
+
+      def assert_received(subject, &block)
+        block.call(received(subject)).call
+      end
     end
   end
 end

data/lib/rr/double.rb

@@ -16,7 +16,7 @@ module RR
       end
     end
 
-    attr_reader :times_called, :double_injection, :definition
+    attr_reader :times_called, :double_injection, :definition, :times_called_expectation
     include Space::Reader
 
     def initialize(double_injection, definition)
@@ -25,193 +25,10 @@ module RR
       @times_called = 0
       @times_called_expectation = Expectations::TimesCalledExpectation.new(self)
       definition.double = self
+      verify_method_signature if definition.verify_method_signature?
       double_injection.register_double self
     end
-
-    # 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, &returns)
-      definition.with(*args, &returns)
-    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(&returns)
-      definition.with_any_args(&returns)
-    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(&returns)
-      definition.with_no_args(&returns)
-    end
-
-    # 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
-      definition.never
-    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(&returns)
-      definition.once(&returns)
-    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(&returns)
-      definition.twice(&returns)
-    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, &returns)
-      definition.at_least(number, &returns)
-    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, &returns)
-      definition.at_most(number, &returns)
-    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(&returns)
-      definition.any_number_of_times(&returns)
-    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(number, &returns)
-      definition.times(number, &returns)
-    end
-
-    # 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(&returns)
-      definition.ordered(&returns)
-    end
-
-    # Double#ordered? returns true when the Double is ordered.
-    #
-    #   mock(subject).method_name.ordered?
-    def ordered?
-      definition.ordered?
-    end
-
-    # Double#verbose sets the Double to print out each method call it receives.
-    #
-    # Passing in a block sets the return value
-    def verbose(&block)
-      definition.verbose(&block)
-    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?
-      definition.verbose?
-    end
-
-    # 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, &returns)
-      definition.yields(*args, &returns)
-    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(&block)
-      definition.after_call &block
-    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)
-      definition.returns(*args, &implementation)
-    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)
-      definition.implemented_by implementation
-    end
-
+    
     # Double#call calls the Double's implementation. The return
     # value of the implementation is returned.
     #
@@ -228,23 +45,6 @@ module RR
       definition.after_call_proc ? extract_subject_from_return_value(definition.after_call_proc.call(return_value)) : return_value
     end
 
-    def yields!(block)
-      if definition.yields_value
-        if block
-          block.call(*definition.yields_value)
-        else
-          raise ArgumentError, "A Block must be passed into the method call when using yields"
-        end
-      end
-    end
-    protected :yields!
-
-    def call_implementation(double_injection, *args, &block)
-      return_value = do_call_implementation_and_get_return_value(double_injection, *args, &block)
-      extract_subject_from_return_value(return_value)
-    end
-    protected :call_implementation
-
     # Double#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
     def exact_match?(*arguments)
@@ -260,7 +60,7 @@ module RR
     # Double#attempt? returns true when the
     # TimesCalledExpectation is satisfied.
     def attempt?
-      return true unless definition.times_matcher
+      verify_times_matcher_is_set
       times_called_expectation.attempt?
     end
 
@@ -268,13 +68,13 @@ module RR
     # is satisfied for this double. A TimesCalledError
     # is raised if the TimesCalledExpectation is not met.
     def verify
-      return true unless definition.times_matcher
+      verify_times_matcher_is_set
       times_called_expectation.verify!
       true
     end
 
     def terminal?
-      return false unless definition.times_matcher
+      verify_times_matcher_is_set
       times_called_expectation.terminal?
     end
 
@@ -285,41 +85,85 @@ module RR
 
     # The Arguments that this Double expects
     def expected_arguments
-      return [] unless argument_expectation
+      verify_argument_expectation_is_set
       argument_expectation.expected_arguments
     end
 
     # The TimesCalledMatcher for the TimesCalledExpectation
     def times_matcher
-      times_called_expectation.matcher
+      definition.times_matcher
     end
 
-    def times_called_expectation
-      @times_called_expectation.matcher = definition.times_matcher
-      @times_called_expectation
+    def formatted_name
+      self.class.formatted_name(method_name, expected_arguments)
     end
 
-    def implementation
-      definition.implementation
+    protected
+    def ordered?
+      definition.ordered?
+    end
+
+    def verbose?
+      definition.verbose?
     end
-    def implementation=(value)
-      definition.implementation = value
+    
+    def yields!(block)
+      if definition.yields_value
+        if block
+          block.call(*definition.yields_value)
+        else
+          raise ArgumentError, "A Block must be passed into the method call when using yields"
+        end
+      end
     end
-    protected :implementation=
 
-    def argument_expectation
-      definition.argument_expectation
+    def call_implementation(double_injection, *args, &block)
+      return_value = do_call_implementation_and_get_return_value(double_injection, *args, &block)
+      extract_subject_from_return_value(return_value)
     end
-    def argument_expectation=(value)
-      definition.argument_expectation = value
+
+    def verify_times_matcher_is_set
+      unless definition.times_matcher
+        raise RR::Errors::DoubleDefinitionError, "#definition.times_matcher is not set"
+      end
     end
-    protected :argument_expectation=
 
-    def formatted_name
-      self.class.formatted_name(method_name, expected_arguments)
+    def verify_argument_expectation_is_set
+      unless definition.argument_expectation
+        raise RR::Errors::DoubleDefinitionError, "#definition.argument_expectation is not set"
+      end
     end
 
-    protected
+    def verify_method_signature
+      raise RR::Errors::SubjectDoesNotImplementMethodError unless definition.subject.respond_to?(double_injection.send(:original_method_name))
+      raise RR::Errors::SubjectHasDifferentArityError unless arity_matches?
+    end
+    
+    def subject_arity
+      definition.subject.method(double_injection.send(:original_method_name)).arity
+    end
+    
+    def subject_accepts_only_varargs?
+      subject_arity == -1
+    end
+    
+    def subject_accepts_varargs?
+      subject_arity < 0
+    end
+    
+    def arity_matches?
+      return true if subject_accepts_only_varargs?
+      if subject_accepts_varargs?
+        return ((subject_arity * -1) - 1) <= args.size
+      else
+        return subject_arity == args.size
+      end
+    end
+    
+    def args
+      definition.argument_expectation.expected_arguments
+    end
+    
     def do_call_implementation_and_get_return_value(double_injection, *args, &block)
       if definition.implementation_is_original_method?
         if double_injection.object_has_original_method?
@@ -349,12 +193,20 @@ module RR
     def extract_subject_from_return_value(return_value)
       case return_value
       when DoubleDefinitions::DoubleDefinition
-        return_value.subject
+        return_value.root_subject
       when DoubleDefinitions::DoubleDefinitionCreatorProxy
-        return_value.__creator__.subject
+        return_value.__creator__.root_subject
       else
         return_value
       end
     end
+
+    def implementation
+      definition.implementation
+    end
+
+    def argument_expectation
+      definition.argument_expectation
+    end    
   end
-end
+end