jferris-rr 0.7.1.0.1239654108

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

@@ -0,0 +1,123 @@
+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 :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
+    # in subject and method_name.
+    # When a DoubleInjection is created, it binds the dispatcher to the
+    # subject.
+    def double_injection(subject, method_name)
+      @double_injections[subject][method_name.to_sym] ||= begin
+        DoubleInjection.new(subject, method_name.to_sym).bind
+      end
+    end
+
+    def double_injection_exists?(subject, method_name)
+      !!@double_injections[subject][method_name.to_sym]
+    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(*objects)
+      objects = @double_injections.keys if objects.empty?
+      objects.each do |subject|
+        @double_injections[subject].keys.each do |method_name|
+          verify_double(subject, method_name)
+        end
+      end
+    end
+    alias_method :verify, :verify_doubles
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      reset_ordered_doubles
+      reset_double_injections
+      reset_recorded_calls
+    end
+
+    # Verifies the DoubleInjection for the passed in subject and method_name.
+    def verify_double(subject, method_name)
+      @double_injections[subject][method_name].verify
+    ensure
+      reset_double subject, method_name
+    end
+
+    # Resets the DoubleInjection for the passed in subject and method_name.
+    def reset_double(subject, method_name)
+      double_injection = @double_injections[subject].delete(method_name)
+      @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
+    def reset_ordered_doubles
+      @ordered_doubles.clear
+    end
+
+    # Resets the registered Doubles for the next test run.
+    def reset_double_injections
+      @double_injections.each do |subject, method_double_map|
+        method_double_map.keys.each do |method_name|
+          reset_double(subject, method_name)
+        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

@@ -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

data/lib/rr/times_called_matchers/at_most_matcher.rb

@@ -0,0 +1,23 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtMostMatcher < TimesCalledMatcher
+      include Terminal
+
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called <= @times
+      end
+
+      def attempt?(times_called)
+        times_called < @times
+      end
+
+      def expected_times_message
+        "at most #{@times.inspect} times"
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/integer_matcher.rb

@@ -0,0 +1,19 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class IntegerMatcher < TimesCalledMatcher
+      include Terminal
+
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called == @times
+      end
+
+      def attempt?(times_called)
+        times_called < @times
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/non_terminal.rb

@@ -0,0 +1,27 @@
+module RR
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as NonTerminal.
+    # Being NonTerminal means the Double will not "terminate" even when
+    # called infinite times.
+    #
+    # The Double that uses a NonTerminal TimesCalledMatcher will
+    # continue using the Double when passed the matching arguments.
+    # This is done by the attempt? always returning true.
+    #
+    # This is in opposition to Terminal TimesCalledMatchers, where
+    # attempt? will eventually return false.
+    module NonTerminal #:nodoc:
+      def terminal?
+        false
+      end
+
+      def possible_match?(times_called)
+        true
+      end
+
+      def attempt?(times_called)
+        true
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/proc_matcher.rb

@@ -0,0 +1,11 @@
+module RR
+  module TimesCalledMatchers
+    class ProcMatcher < TimesCalledMatcher #:nodoc:
+      include NonTerminal
+
+      def matches?(times_called)
+        @times.call(times_called)
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/range_matcher.rb

@@ -0,0 +1,21 @@
+module RR
+  module TimesCalledMatchers
+    class RangeMatcher < TimesCalledMatcher #:nodoc:
+      include Terminal
+
+      def possible_match?(times_called)
+        return true if times_called < @times.begin
+        return true if @times.include?(times_called)
+        return false
+      end
+
+      def matches?(times_called)
+        @times.include?(times_called)
+      end
+
+      def attempt?(times_called)
+        possible_match?(times_called)
+      end
+    end
+  end
+end

data/lib/rr/times_called_matchers/terminal.rb

@@ -0,0 +1,20 @@
+module RR
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as Terminal.
+    # Being Terminal the Double will "terminate" when times called is
+    # finite.
+    #
+    # The Double that uses a Terminal TimesCalledMatcher will
+    # eventually be passed over to the next Double when passed
+    # the matching arguments enough times. This is done by the attempt?
+    # method returning false when executed a finite number of times.
+    #
+    # This is in opposition to NonTerminal TimesCalledMatchers, where
+    # attempt? will always return true.
+    module Terminal #:nodoc:
+      def terminal?
+        true
+      end
+    end
+  end
+end