mcmire-rr 1.0.5.rc1

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -0,0 +1,59 @@
+module RR
+  module MethodDispatches
+    class MethodDispatch < BaseMethodDispatch
+      attr_reader :double_injection, :subject
+      def initialize(double_injection, subject, args, block)
+        @double_injection, @subject, @args, @block = double_injection, subject, args, block
+        @double = find_double_to_attempt
+      end
+
+      def call
+        space.record_call(subject, method_name, args, block)
+        if double
+          double.method_call(args)
+          call_yields
+          return_value_1 = call_implementation
+          return_value_2 = extract_subject_from_return_value(return_value_1)
+          if after_call_proc
+            extract_subject_from_return_value(after_call_proc.call(return_value_2))
+          else
+            return_value_2
+          end
+        else
+          double_not_found_error
+        end
+      end
+
+      def call_original_method
+        if subject_has_original_method?
+          subject.__send__(original_method_alias_name, *args, &block)
+        elsif subject_has_original_method_missing?
+          call_original_method_missing
+        else
+          subject.__send__(:method_missing, method_name, *args, &block)
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          call_original_method
+        else
+          if implementation
+            if implementation.is_a?(Method)
+              implementation.call(*args, &block)
+            else
+              call_args = block ? args + [ProcFromBlock.new(&block)] : args
+              implementation.call(*call_args)
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      def_delegators :definition, :implementation
+      def_delegators :double_injection, :subject_has_original_method?, :subject_has_original_method_missing?, :method_name, :original_method_alias_name
+    end
+  end
+end

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -0,0 +1,61 @@
+module RR
+  module MethodDispatches
+    class MethodMissingDispatch < BaseMethodDispatch
+      extend(Module.new do
+        def original_method_missing_alias_name
+          "__rr__original_method_missing"
+        end
+      end)
+
+      attr_reader :subject, :subject_class, :method_name
+      def initialize(subject, subject_class, method_name, args, block)
+        @subject, @subject_class, @method_name, @args, @block = subject, subject_class, method_name, args, block
+      end
+
+      def call
+        if Injections::DoubleInjection.exists?(subject_class, method_name)
+          @double = find_double_to_attempt
+          if double
+            return_value = extract_subject_from_return_value(call_implementation)
+            if after_call_proc
+              extract_subject_from_return_value(after_call_proc.call(return_value))
+            else
+              return_value
+            end
+          else
+            double_not_found_error
+          end
+        else
+          call_original_method
+        end
+      end
+
+      def call_original_method
+        Injections::DoubleInjection.find_or_create(subject_class, method_name).dispatch_method_delegates_to_dispatch_original_method do
+          call_original_method_missing
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          space.record_call(subject, method_name, args, block)
+          double.method_call(args)
+          call_original_method
+        else
+          if double_injection = Injections::DoubleInjection.find(subject_class, method_name)
+            double_injection.bind_method
+            # The DoubleInjection takes care of calling double.method_call
+            subject.__send__(method_name, *args, &block)
+          else
+            nil
+          end
+        end
+      end
+
+      def double_injection
+        Injections::DoubleInjection.find_or_create(subject_class, method_name)
+      end
+    end
+  end
+end

data/lib/rr/proc_from_block.rb

@@ -0,0 +1,7 @@
+module RR
+  class ProcFromBlock < Proc
+    def ==(other)
+      Proc.new(&self) == other
+    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 Injections::DoubleInjection.exists_by_subject?(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

@@ -0,0 +1,119 @@
+module RR
+  # RR::Space.instance is the global state subject for the RR framework.
+  class Space
+    module Reader
+      def space
+        RR::Space.instance
+      end
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+      attr_writer :instance
+
+      protected
+      def method_missing(method_name, *args, &block)
+        instance.__send__(method_name, *args, &block)
+      end
+    end
+
+    attr_reader :ordered_doubles, :recorded_calls
+    attr_accessor :trim_backtrace
+    def initialize
+      @ordered_doubles = []
+      @trim_backtrace = false
+      @recorded_calls = RR::RecordedCalls.new
+    end
+
+    # Registers the ordered Double to be verified.
+    def register_ordered_double(double)
+      @ordered_doubles << double unless ordered_doubles.include?(double)
+    end
+
+    # Verifies that the passed in ordered Double is being called
+    # in the correct position.
+    def verify_ordered_double(double)
+      unless double.terminal?
+        raise Errors::DoubleOrderError,
+              "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+      end
+      unless @ordered_doubles.first == double
+        message = Double.formatted_name(double.method_name, double.expected_arguments)
+        message << " called out of order in list\n"
+        message << Double.list_message_part(@ordered_doubles)
+        raise Errors::DoubleOrderError, message
+      end
+      @ordered_doubles.shift unless double.attempt?
+      double
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify_doubles(*subjects)
+      Injections::DoubleInjection.verify(*subjects)
+    end
+    alias_method :verify, :verify_doubles
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      reset_ordered_doubles
+      Injections::DoubleInjection.reset
+      reset_method_missing_injections
+      reset_singleton_method_added_injections
+      reset_recorded_calls
+      reset_bound_objects
+    end
+
+    # Verifies the DoubleInjection for the passed in subject and method_name.
+    def verify_double(subject, method_name)
+      Injections::DoubleInjection.verify_double(class << subject; self; end, method_name)
+    end
+
+    # Resets the DoubleInjection for the passed in subject and method_name.
+    def reset_double(subject, method_name)
+      Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
+    end
+
+    def record_call(subject, method_name, arguments, block)
+      @recorded_calls << [subject, method_name, arguments, block]
+    end
+
+    def blank_slate_whitelist
+      @blank_slate_whitelist ||= [
+        "object_id", "respond_to?", "respond_to_missing?", "method_missing", "instance_eval", "instance_exec", "class_eval"
+      ]
+    end
+
+    protected
+    # Removes the ordered Doubles from the list
+    def reset_ordered_doubles
+      @ordered_doubles.clear
+    end
+
+    def reset_method_missing_injections
+      Injections::MethodMissingInjection.instances.each do |subject_class, injection|
+        injection.reset
+      end
+      Injections::MethodMissingInjection.instances.clear
+    end
+
+    def reset_singleton_method_added_injections
+      Injections::SingletonMethodAddedInjection.instances.each do |subject, injection|
+        injection.reset
+      end
+      Injections::SingletonMethodAddedInjection.instances.clear
+    end
+
+    def reset_recorded_calls
+      @recorded_calls.clear
+    end
+
+    def reset_bound_objects
+      # TODO: Figure out how to clear and reset these bindings
+      #RR::Injections::DoubleInjection::BoundObjects.clear
+      #RR::Injections::DoubleInjection::MethodMissingInjection.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,13 @@
+module RR
+  class SpyVerificationProxy
+    BlankSlate.call(self)
+
+    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

@@ -0,0 +1,18 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AnyTimesMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def initialize
+      end
+
+      def matches?(times_called)
+        true
+      end
+
+      def expected_times_message
+        "any number of times"
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/at_least_matcher.rb

@@ -0,0 +1,15 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtLeastMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def matches?(times_called)
+        times_called >= @times
+      end
+
+      def expected_times_message
+        "at least #{@times.inspect} times"
+      end
+    end
+  end
+end