rr 0.6.0 → 0.7.0

data/lib/rr/errors/spy_verification_errors/double_injection_not_found_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class DoubleInjectionNotFoundError < SpyVerificationError
+      end      
+    end
+  end
+end

data/lib/rr/errors/spy_verification_errors/invocation_count_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class InvocationCountError < SpyVerificationError
+      end
+    end
+  end
+end

data/lib/rr/errors/spy_verification_errors/spy_verification_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class SpyVerificationError < RRError
+      end
+    end
+  end
+end

data/lib/rr/errors/subject_does_not_implement_method_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectDoesNotImplementMethodError < RRError
+    end
+  end
+end

data/lib/rr/errors/subject_has_different_arity_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectHasDifferentArityError < RRError
+    end
+  end
+end

data/lib/rr/expectations/times_called_expectation.rb

@@ -2,28 +2,26 @@ module RR
   module Expectations
     class TimesCalledExpectation #:nodoc:
       attr_reader :double, :times_called
-      attr_accessor :matcher
 
-      def initialize(double, matcher=nil)
+      def initialize(double)
         @double = double
-        @matcher = matcher
         @times_called = 0
         @verify_backtrace = caller[1..-1]
       end
 
       def attempt?
-        @matcher.attempt?(@times_called)
+        times_matcher.attempt?(@times_called)
       end
 
       def attempt
         @times_called += 1
-        verify_input_error unless @matcher.possible_match?(@times_called)
+        verify_input_error unless times_matcher.possible_match?(@times_called)
         return
       end
 
       def verify
-        return false unless @matcher.is_a?(TimesCalledMatchers::TimesCalledMatcher)
-        return @matcher.matches?(@times_called)
+        return false unless times_matcher.is_a?(TimesCalledMatchers::TimesCalledMatcher)
+        return times_matcher.matches?(@times_called)
       end
 
       def verify!
@@ -39,16 +37,20 @@ module RR
       end
 
       def terminal?
-        @matcher.terminal?
+        times_matcher.terminal?
       end
 
       protected
+      def times_matcher
+        double.definition.times_matcher
+      end
+
       def verify_input_error
         raise Errors::TimesCalledError, error_message
       end
 
       def error_message
-        "#{double.formatted_name}\n#{@matcher.error_message(@times_called)}"
+        "#{double.formatted_name}\n#{times_matcher.error_message(@times_called)}"
       end
     end
   end

data/lib/rr/recorded_calls.rb

@@ -0,0 +1,103 @@
+module RR
+  class RecordedCalls
+    include RR::Space::Reader
+
+    def initialize(recorded_calls=[])
+      @recorded_calls = recorded_calls
+      @ordered_index = 0
+    end
+  
+    attr_reader :recorded_calls
+  
+    def clear
+      self.ordered_index = 0
+      recorded_calls.clear
+    end
+  
+    def <<(recorded_call)
+      recorded_calls << recorded_call
+    end
+  
+    def any?(&block)
+      recorded_calls.any?(&block)
+    end
+  
+    def ==(other)
+      recorded_calls == other.recorded_calls
+    end
+  
+    def match_error(spy_verification)
+      double_injection_exists_error(spy_verification) || begin
+        if spy_verification.ordered?
+          ordered_match_error(spy_verification)
+        else
+          unordered_match_error(spy_verification)
+        end
+      end
+    end
+  
+  protected
+    attr_accessor :ordered_index
+
+    def double_injection_exists_error(spy_verification)
+      unless space.double_injection_exists?(spy_verification.subject, spy_verification.method_name)
+        RR::Errors::SpyVerificationErrors::DoubleInjectionNotFoundError.new(
+          "A Double Injection for the subject and method call:\n" <<
+          "#{spy_verification.subject.inspect}\n" <<
+          "#{spy_verification.method_name}\ndoes not exist in:\n" <<
+          "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
+        )
+      end
+    end    
+
+    def ordered_match_error(spy_verification)
+      memoized_matching_recorded_calls = matching_recorded_calls(spy_verification)
+
+      if memoized_matching_recorded_calls.last
+        self.ordered_index = recorded_calls.index(memoized_matching_recorded_calls.last)
+      end
+      (0..memoized_matching_recorded_calls.size).to_a.any? do |i|
+        spy_verification.times_matcher.matches?(i)
+      end ? nil : invocation_count_error(spy_verification, memoized_matching_recorded_calls)
+    end
+
+    def unordered_match_error(spy_verification)
+      memoized_matching_recorded_calls = matching_recorded_calls(spy_verification)
+      
+      spy_verification.times_matcher.matches?(
+        memoized_matching_recorded_calls.size
+      ) ? nil : invocation_count_error(spy_verification, memoized_matching_recorded_calls)
+    end
+
+    def matching_recorded_calls(spy_verification)
+      recorded_calls[ordered_index..-1].
+        select(&match_double_injection(spy_verification)).
+        select(&match_argument_expectation(spy_verification))
+    end
+
+    def match_double_injection(spy_verification)
+      lambda do |recorded_call|
+        recorded_call[0] == spy_verification.subject &&
+        recorded_call[1] == spy_verification.method_name
+      end
+    end
+
+    def match_argument_expectation(spy_verification)
+      lambda do |recorded_call|
+        spy_verification.argument_expectation.exact_match?(*recorded_call[2]) ||
+        spy_verification.argument_expectation.wildcard_match?(*recorded_call[2])
+      end
+    end
+
+    def invocation_count_error(spy_verification, matching_recorded_calls)
+      RR::Errors::SpyVerificationErrors::InvocationCountError.new(
+        "On subject #{spy_verification.subject.inspect}\n" <<
+        "Expected #{Double.formatted_name(spy_verification.method_name, spy_verification.argument_expectation.expected_arguments)}\n" <<
+        "to be called #{spy_verification.times_matcher.expected_times_message},\n" <<
+        "but was called #{matching_recorded_calls.size} times.\n" <<
+        "All of the method calls related to Doubles are:\n" <<
+        "\t#{recorded_calls.map {|call| call.inspect}.join("\n\t")}"
+      )
+    end
+  end
+end

data/lib/rr/space.rb

@@ -19,12 +19,13 @@ module RR
       end
     end
 
-    attr_reader :double_injections, :ordered_doubles
+    attr_reader :double_injections, :ordered_doubles, :recorded_calls
     attr_accessor :trim_backtrace
     def initialize
       @double_injections = HashWithObjectIdKey.new
       @ordered_doubles = []
       @trim_backtrace = false
+      @recorded_calls = RR::RecordedCalls.new
     end
 
     # Reuses or creates, if none exists, a DoubleInjection for the passed
@@ -32,13 +33,13 @@ module RR
     # When a DoubleInjection is created, it binds the dispatcher to the
     # subject.
     def double_injection(subject, method_name)
-      double_injection = @double_injections[subject][method_name.to_sym]
-      return double_injection if double_injection
+      @double_injections[subject][method_name.to_sym] ||= begin
+        DoubleInjection.new(subject, method_name.to_sym).bind
+      end
+    end
 
-      double_injection = DoubleInjection.new(subject, method_name.to_sym)
-      @double_injections[subject][method_name.to_sym] = double_injection
-      double_injection.bind
-      double_injection
+    def double_injection_exists?(subject, method_name)
+      !!@double_injections[subject][method_name.to_sym]
     end
 
     # Registers the ordered Double to be verified.
@@ -79,6 +80,7 @@ module RR
     def reset
       reset_ordered_doubles
       reset_double_injections
+      reset_recorded_calls
     end
 
     # Verifies the DoubleInjection for the passed in subject and method_name.
@@ -94,6 +96,10 @@ module RR
       @double_injections.delete(subject) if @double_injections[subject].empty?
       double_injection.reset
     end
+    
+    def record_call(subject, method_name, arguments, block)
+      @recorded_calls << [subject, method_name, arguments, block]
+    end
 
     protected
     # Removes the ordered Doubles from the list
@@ -108,6 +114,10 @@ module RR
           reset_double(subject, method_name)
         end
       end
-    end    
+    end  
+    
+    def reset_recorded_calls
+      @recorded_calls.clear
+    end
   end
 end

data/lib/rr/spy_verification.rb

@@ -0,0 +1,48 @@
+module RR
+  class SpyVerification
+    def initialize(subject, method_name, args)
+      @subject = subject
+      @method_name = method_name.to_sym
+      set_argument_expectation_for_args(args)
+      @ordered = false
+      once
+    end
+
+    attr_reader :argument_expectation, :method_name, :times_matcher
+    attr_accessor :subject
+
+    include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
+    include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
+  
+    def ordered
+      @ordered = true
+      self
+    end
+  
+    def ordered?
+      @ordered
+    end
+
+    def call
+      (error = RR.recorded_calls.match_error(self)) && raise(error)
+    end
+
+    def to_proc
+      lambda do
+        call
+      end
+    end
+  
+  protected
+    attr_writer :times_matcher
+
+    def set_argument_expectation_for_args(args)
+      # with_no_args and with actually set @argument_expectation
+      args.empty? ? with_no_args : with(*args)
+    end
+  
+    def install_method_callback(return_value_block)
+      # Do nothing. This is to support DefinitionConstructionMethods
+    end
+  end
+end

data/lib/rr/spy_verification_proxy.rb

@@ -0,0 +1,18 @@
+module RR
+  class SpyVerificationProxy
+    instance_methods.each do |m|
+      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 initialize(subject)
+      @subject = subject
+    end
+  
+    def method_missing(method_name, *args, &block)
+      SpyVerification.new(@subject, method_name, args)
+    end  
+  end
+end

data/lib/rr/times_called_matchers/any_times_matcher.rb

@@ -10,9 +10,8 @@ module RR
         true
       end
 
-      protected
-      def expected_message_part
-        "Expected any number of times."
+      def expected_times_message
+        "any number of times"
       end
     end
   end

data/lib/rr/times_called_matchers/at_least_matcher.rb

@@ -7,9 +7,8 @@ module RR
         times_called >= @times
       end
 
-      protected
-      def expected_message_part
-        "Expected at least #{@times.inspect} times."
+      def expected_times_message
+        "at least #{@times.inspect} times"
       end
     end
   end

data/lib/rr/times_called_matchers/at_most_matcher.rb

@@ -15,9 +15,8 @@ module RR
         times_called < @times
       end
 
-      protected
-      def expected_message_part
-        "Expected at most #{@times.inspect} times."
+      def expected_times_message
+        "at most #{@times.inspect} times"
       end
     end
   end

data/lib/rr/times_called_matchers/times_called_matcher.rb

@@ -24,18 +24,18 @@ module RR
       end
 
       def error_message(times_called)
-        "Called #{times_called.inspect} #{pluralized_time(times_called)}.\n#{expected_message_part}"
+        "Called #{times_called.inspect} #{pluralized_time(times_called)}.\nExpected #{expected_times_message}."
       end
 
       def ==(other)
         self.class == other.class && self.times == other.times
       end
 
-      protected
-      def expected_message_part
-        "Expected #{@times.inspect} times."
+      def expected_times_message
+        "#{@times.inspect} times"
       end
 
+      protected
       def pluralized_time(times_called)
         (times_called == 1) ? "time" : "times"
       end

data/spec/core_spec_suite.rb

@@ -9,6 +9,7 @@ class CoreExampleSuite
     puts "Running Rspec Example Suite"
     files.each do |file|
       require file
+#      puts "require '#{file}'"
     end
   end
 end

data/spec/high_level_spec.rb

@@ -14,7 +14,7 @@ describe "RR" do
     RR.reset
   end
 
-  describe "RR mock:" do
+  describe "mock" do
     it "mocks via inline call" do
       mock(subject).to_s {"a value"}
       subject.to_s.should == "a value"
@@ -29,14 +29,20 @@ describe "RR" do
       subject.to_s.should == "value 2"
       lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
     end
-    
+
     it 'allows terse chaining' do
       mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
       subject.first(1).second(2).third(3).should == 4
 
       mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
       subject.first(1).second(2).third(3).should == 4
-      
+
+      mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
+      subject.first(1).second(2).third(3).should == 4
+
+      mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
+      subject.first(1).second(2).third(3).should == 4
+
       mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
       subject.first(1).second(2).third(3).should == 4
     end
@@ -55,7 +61,7 @@ describe "RR" do
       mock.proxy(subject).find('1').mock.proxy!.child
       subject.find('1').child.should == :the_child
     end
-    
+
     it 'allows branched chaining' do
       mock(subject).first do
         mock! do |expect|
@@ -67,7 +73,7 @@ describe "RR" do
       o.branch1.branch11.should == 11
       o.branch2.branch22.should == 22
     end
-    
+
     it 'allows chained ordering' do
       mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
       subject.to_s.should == "value 1"
@@ -77,7 +83,7 @@ describe "RR" do
       lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
     end
 
-    it "mocks via block" do
+    it "mocks via block with argument" do
       mock subject do |c|
         c.to_s {"a value"}
         c.to_sym {:crazy}
@@ -86,6 +92,15 @@ describe "RR" do
       subject.to_sym.should == :crazy
     end
 
+    it "mocks via block without argument" do
+      mock subject do
+        to_s {"a value"}
+        to_sym {:crazy}
+      end
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
+    end
+
     it "has wildcard matchers" do
       mock(subject).foobar(
         is_a(String),
@@ -118,7 +133,7 @@ describe "RR" do
     end
   end
 
-  describe "RR proxy:" do
+  describe "proxy" do
     it "proxies via inline call" do
       expected_to_s_value = subject.to_s
       mock.proxy(subject).to_s
@@ -152,7 +167,7 @@ describe "RR" do
       lambda {subject.to_s(:bar)}.should raise_error(RR::Errors::TimesCalledError)
     end
 
-    it "proxies via block" do
+    it "proxies via block with argument" do
       def subject.foobar_1(*args)
         :original_value_1
       end
@@ -172,7 +187,7 @@ describe "RR" do
       lambda {subject.foobar_2(:blah)}.should raise_error
     end
 
-    it "proxies via block" do
+    it "proxies via block without argument" do
       def subject.foobar_1(*args)
         :original_value_1
       end
@@ -181,9 +196,9 @@ describe "RR" do
         :original_value_2
       end
 
-      mock.proxy subject do |c|
-        c.foobar_1(1)
-        c.foobar_2
+      mock.proxy subject do
+        foobar_1(1)
+        foobar_2
       end
       subject.foobar_1(1).should == :original_value_1
       lambda {subject.foobar_1(:blah)}.should raise_error
@@ -193,7 +208,7 @@ describe "RR" do
     end
   end
 
-  describe "RR stub:" do
+  describe "stub" do
     it "stubs via inline call" do
       stub(subject).to_s {"a value"}
       subject.to_s.should == "a value"
@@ -207,7 +222,7 @@ describe "RR" do
       subject.to_s.should == "value 2"
     end
 
-    it "stubs via block" do
+    it "stubs via block with argument" do
       stub subject do |d|
         d.to_s {"a value"}
         d.to_sym {:crazy}
@@ -216,6 +231,15 @@ describe "RR" do
       subject.to_sym.should == :crazy
     end
 
+    it "stubs via block without argument" do
+      stub subject do
+        to_s {"a value"}
+        to_sym {:crazy}
+      end
+      subject.to_s.should == "a value"
+      subject.to_sym.should == :crazy
+    end
+
     it "stubs instance_of" do
       stub.instance_of(HighLevelSpec) do |o|
         o.to_s {"High Level Spec"}
@@ -228,4 +252,117 @@ describe "RR" do
       (subject == 55).should == :equality
     end
   end
+
+  describe "RR recorded_calls" do
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      subject.pig_rabbit("bacon", "bunny meat")
+      #subject.should have_received.pig_rabitt("bacon", "bunny meat")
+      received(subject).pig_rabbit("bacon", "bunny meat").call
+    end
+    
+    it "should verify method calls after the fact" do
+      stub(subject).pig_rabbit
+      lambda do
+        received(subject).pig_rabbit("bacon", "bunny meat").call
+      end.should raise_error(RR::Errors::SpyVerificationErrors::SpyVerificationError)
+    end
+  end
+  
+  class StrongTestObject
+    def method_with_no_arguments
+    end
+
+    def method_with_one_argument(string)
+    end
+
+    def method_with_two_arguments(string, integer)
+    end
+
+    def method_with_three_arguments_including_varargs(string, integer, *args)
+    end
+
+    def method_with_varargs(*args)
+    end
+  end
+
+  describe "strong" do
+    context "when the method does not exist" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).something
+        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+
+    context "when the method exists with no arguments" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_no_arguments
+      end
+    end
+
+    context "when the method has a different arity" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).method_with_one_argument
+        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+      end
+    end
+
+    context "when the method has accepts a variable number of arguments" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_varargs
+      end
+    end
+
+    context "when the method does not provide the required parameters before varargs" do
+      it "raises an exception" do
+        lambda do
+          strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs
+        end.should raise_error(RR::Errors::SubjectHasDifferentArityError)
+      end
+    end
+
+    context "when the minimum number of parameters are provided" do
+      it "does not raise an exception" do
+        strong.stub(StrongTestObject.new).method_with_three_arguments_including_varargs("one", 2)
+      end
+    end
+
+    context "when using instance_of and the method does not exist" do
+      it "raises an exception" do
+        lambda do
+          strong.stub.instance_of(StrongTestObject).something
+          StrongTestObject.new
+        end.should raise_error(RR::Errors::SubjectDoesNotImplementMethodError)
+      end
+    end
+
+    context "when using instance_of and the method does exist" do
+      it "does not raise an exception" do
+        strong.stub.instance_of(StrongTestObject).method_with_no_arguments
+      end
+    end
+  end
+
+  describe "spy" do
+    it "should record all method invocations" do
+      subject = Object.new
+      def subject.something
+      end
+
+      def subject.something_else
+      end
+
+      spy(subject)
+
+      subject.something
+      subject.something_else
+      subject.to_s
+
+      received(subject).something.call
+      received(subject).something_else.call
+      received(subject).to_s.call
+    end
+  end
 end