mocha 0.5.6 → 0.9.0

data/lib/mocha/configuration.rb

@@ -0,0 +1,60 @@
+module Mocha # :nodoc:
+  
+  # Configuration settings
+  class Configuration
+    
+    DEFAULTS = { :stubbing_method_unnecessarily => :allow, :stubbing_method_on_non_mock_object => :allow, :stubbing_non_existent_method => :allow, :stubbing_non_public_method => :allow }
+    
+    class << self
+    
+      # :call-seq: allow(action)
+      #
+      # Allow the specified <tt>action</tt> (as a symbol).
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def allow(action)
+        configuration[action] = :allow
+      end
+    
+      def allow?(action) # :nodoc:
+        configuration[action] == :allow
+      end
+    
+      # :call-seq: warn_when(action)
+      #
+      # Warn if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def warn_when(action)
+        configuration[action] = :warn
+      end
+    
+      def warn_when?(action) # :nodoc:
+        configuration[action] == :warn
+      end
+    
+      # :call-seq: prevent(action)
+      #
+      # Raise a StubbingError if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      def prevent(action)
+        configuration[action] = :prevent
+      end
+    
+      def prevent?(action) # :nodoc:
+        configuration[action] == :prevent
+      end
+    
+      def reset_configuration # :nodoc:
+        @configuration = nil
+      end
+    
+      private
+    
+      def configuration # :nodoc:
+        @configuration ||= DEFAULTS.dup
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/mocha/exception_raiser.rb

@@ -7,7 +7,7 @@ module Mocha # :nodoc:
     end
     
     def evaluate
-      raise @exception, @exception.to_s if @exception == Interrupt
+      raise @exception, @exception.to_s if @exception.is_a?(Module) && @exception.ancestors.include?(Interrupt)
       raise @exception, @message if @message
       raise @exception
     end

data/lib/mocha/expectation.rb

@@ -1,4 +1,3 @@
-require 'mocha/infinite_range'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/expectation_error'
@@ -6,6 +5,9 @@ require 'mocha/return_values'
 require 'mocha/exception_raiser'
 require 'mocha/yield_parameters'
 require 'mocha/is_a'
+require 'mocha/in_state_ordering_constraint'
+require 'mocha/change_state_side_effect'
+require 'mocha/cardinality'
 
 module Mocha # :nodoc:
   
@@ -37,7 +39,7 @@ module Mocha # :nodoc:
     #   object.expected_method
     #   # => verify fails
     def times(range)
-      @expected_count = range
+      @cardinality = Cardinality.times(range)
       self
     end
   
@@ -59,8 +61,8 @@ module Mocha # :nodoc:
     #   object = mock()
     #   object.expects(:expected_method).once
     #   # => verify fails
-    def once()
-      times(1)
+    def once
+      @cardinality = Cardinality.exactly(1)
       self
     end
   
@@ -77,7 +79,7 @@ module Mocha # :nodoc:
     #   object.expected_method
     #   # => verify succeeds
     def never
-      times(0)
+      @cardinality = Cardinality.exactly(0)
       self
     end
   
@@ -94,7 +96,7 @@ module Mocha # :nodoc:
     #   object.expected_method
     #   # => verify fails
     def at_least(minimum_number_of_times)
-      times(Range.at_least(minimum_number_of_times))
+      @cardinality = Cardinality.at_least(minimum_number_of_times)
       self
     end
   
@@ -109,7 +111,7 @@ module Mocha # :nodoc:
     #   object = mock()
     #   object.expects(:expected_method).at_least_once
     #   # => verify fails
-    def at_least_once()
+    def at_least_once
       at_least(1)
       self
     end
@@ -127,7 +129,7 @@ module Mocha # :nodoc:
     #   3.times { object.expected_method }
     #   # => verify fails
     def at_most(maximum_number_of_times)
-      times(Range.at_most(maximum_number_of_times))
+      @cardinality = Cardinality.at_most(maximum_number_of_times)
       self
     end
   
@@ -247,16 +249,6 @@ module Mocha # :nodoc:
     #   object.expected_method # => 1
     #   object.expected_method # => 2
     #   object.expected_method # => raises exception of class Exception1
-    # If +value+ is a +Proc+, then the expected method will return the result of calling <tt>Proc#call</tt>.
-    #
-    # This usage is _deprecated_.
-    # Use explicit multiple return values and/or multiple expectations instead.
-    #
-    # A +Proc+ instance will be treated the same as any other value in a future release.
-    #   object = mock()
-    #   object.stubs(:stubbed_method).returns(lambda { rand(100) })
-    #   object.stubbed_method # => 41
-    #   object.stubbed_method # => 77
     def returns(*values)
       @return_values += ReturnValues.build(*values)
       self
@@ -285,25 +277,79 @@ module Mocha # :nodoc:
     end
 
     # :call-seq: then() -> expectation
+    #            then(state_machine.is(state)) -> expectation
     #
-    # Syntactic sugar to improve readability. Has no effect on state of the expectation.
+    # <tt>then()</tt> is used as syntactic sugar to improve readability. It has no effect on state of the expectation.
     #   object = mock()
     #   object.stubs(:expected_method).returns(1, 2).then.raises(Exception).then.returns(4)
     #   object.expected_method # => 1
     #   object.expected_method # => 2
     #   object.expected_method # => raises exception of class Exception
     #   object.expected_method # => 4
-    def then
+    #
+    # <tt>then(state_machine.is(state))</tt> is used to change the +state_machine+ to the specified +state+ when the invocation occurs.
+    #
+    # See also Standalone#states, StateMachine and Expectation#when.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def then(*parameters)
+      if parameters.length == 1
+        state = parameters.first
+        add_side_effect(ChangeStateSideEffect.new(state))
+      end
       self
     end
     
-    # :stopdoc:
+    # :call-seq: when(state_machine.is(state)) -> exception
+    #
+    # Constrains the expectation to occur only when the +state_machine+ is in the named +state+.
+    #
+    # See also Standalone#states, StateMachine#starts_as and Expectation#then.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def when(state_predicate)
+      add_ordering_constraint(InStateOrderingConstraint.new(state_predicate))
+      self
+    end
     
+    # :call-seq: in_sequence(*sequences) -> expectation
+    #
+    # Constrains this expectation so that it must be invoked at the current point in the sequence.
+    #
+    # To expect a sequence of invocations, write the expectations in order and add the in_sequence(sequence) clause to each one.
+    #
+    # Expectations in a sequence can have any invocation count.
+    #
+    # If an expectation in a sequence is stubbed, rather than expected, it can be skipped in the sequence.
+    #
+    # See also Standalone#sequence.
+    #   breakfast = sequence('breakfast')
+    #
+    #   egg = mock('egg')
+    #   egg.expects(:crack).in_sequence(breakfast)
+    #   egg.expects(:fry).in_sequence(breakfast)
+    #   egg.expects(:eat).in_sequence(breakfast)
     def in_sequence(*sequences)
-      sequences.each { |sequence| sequence.constrain_as_next_in_sequence(self) }
+      sequences.each { |sequence| add_in_sequence_ordering_constraint(sequence) }
       self
     end
     
+    # :stopdoc:
+    
     attr_reader :backtrace
 
     def initialize(mock, expected_method_name, backtrace = nil)
@@ -311,7 +357,8 @@ module Mocha # :nodoc:
       @method_matcher = MethodMatcher.new(expected_method_name)
       @parameters_matcher = ParametersMatcher.new
       @ordering_constraints = []
-      @expected_count, @invoked_count = 1, 0
+      @side_effects = []
+      @cardinality, @invocation_count = Cardinality.exactly(1), 0
       @return_values = ReturnValues.new
       @yield_parameters = YieldParameters.new
       @backtrace = backtrace || caller
@@ -321,6 +368,18 @@ module Mocha # :nodoc:
       @ordering_constraints << ordering_constraint
     end
     
+    def add_in_sequence_ordering_constraint(sequence)
+      sequence.constrain_as_next_in_sequence(self)
+    end
+    
+    def add_side_effect(side_effect)
+      @side_effects << side_effect
+    end
+    
+    def perform_side_effects
+      @side_effects.each { |side_effect| side_effect.perform }
+    end
+    
     def in_correct_order?
       @ordering_constraints.all? { |ordering_constraint| ordering_constraint.allows_invocation_now? }
     end
@@ -334,23 +393,16 @@ module Mocha # :nodoc:
     end
     
     def invocations_allowed?
-      if @expected_count.is_a?(Range) then
-        @invoked_count < @expected_count.last
-      else
-        @invoked_count < @expected_count
-      end
+      @cardinality.invocations_allowed?(@invocation_count)
     end
 
     def satisfied?
-      if @expected_count.is_a?(Range) then
-        @invoked_count >= @expected_count.first
-      else
-        @invoked_count >= @expected_count
-      end
+      @cardinality.satisfied?(@invocation_count)
     end
   
     def invoke
-      @invoked_count += 1
+      @invocation_count += 1
+      perform_side_effects()
       if block_given? then
         @yield_parameters.next_invocation.each do |yield_parameters|
           yield(*yield_parameters)
@@ -359,26 +411,35 @@ module Mocha # :nodoc:
       @return_values.next
     end
 
-    def verify
-      yield(self) if block_given?
-      unless (@expected_count === @invoked_count) then
-        error = ExpectationError.new(error_message(@expected_count, @invoked_count), backtrace)
-        raise error
-      end
+    def verified?(assertion_counter = nil)
+      assertion_counter.increment if assertion_counter && @cardinality.needs_verifying?
+      @cardinality.verified?(@invocation_count)
     end
     
-    def method_signature
-      signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
-      signature << "; #{@ordering_constraints.map { |oc| oc.mocha_inspect }.join("; ")}" unless @ordering_constraints.empty?
-      signature
+    def used?
+      @cardinality.used?(@invocation_count)
     end
     
-    def error_message(expected_count, actual_count)
-      "#{method_signature} - expected calls: #{expected_count.mocha_inspect}, actual calls: #{actual_count}"
+    def mocha_inspect
+      message = "#{@cardinality.mocha_inspect}, "
+      if @invocation_count > 0
+        message << "already invoked #{@invocation_count} time"
+        message << "s" if @invocation_count > 1
+      else
+        message << "never invoked"
+      end
+      message << ": "
+      message << method_signature
+      message << "; #{@ordering_constraints.map { |oc| oc.mocha_inspect }.join("; ")}" unless @ordering_constraints.empty?
+      message
     end
-  
+    
+    def method_signature
+      "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+    end
+      
     # :startdoc:
     
   end
 
-end
+end

data/lib/mocha/expectation_error.rb

@@ -1,15 +1,15 @@
+require 'mocha/backtrace_filter'
+
 module Mocha
 
   class ExpectationError < StandardError
     
-    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
-    
-    def initialize(message = nil, backtrace = [], lib_directory = LIB_DIRECTORY)
+    def initialize(message = nil, backtrace = [])
       super(message)
-      filtered_backtrace = backtrace.reject { |location| Regexp.new(lib_directory).match(File.expand_path(location)) }
-      set_backtrace(filtered_backtrace)
+      filter = BacktraceFilter.new
+      set_backtrace(filter.filtered(backtrace))
     end
 
   end
   
-end
+end

data/lib/mocha/expectation_list.rb

@@ -5,42 +5,38 @@ module Mocha # :nodoc:
     def initialize
       @expectations = []
     end
-
+    
     def add(expectation)
       @expectations << expectation
       expectation
     end
-
+    
     def matches_method?(method_name)
       @expectations.any? { |expectation| expectation.matches_method?(method_name) }
     end
-
-    def similar(method_name)
-      @expectations.select { |expectation| expectation.matches_method?(method_name) }
-    end
-
+    
     def detect(method_name, *arguments)
       expectations = @expectations.reverse.select { |e| e.match?(method_name, *arguments) }
       expectation = expectations.detect { |e| e.invocations_allowed? }
       expectation || expectations.first
     end
-
-    def verify(&block)
-      @expectations.each { |expectation| expectation.verify(&block) }
+    
+    def verified?(assertion_counter = nil)
+      @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
     end
-
+    
     def to_a
       @expectations
     end
-
+    
     def to_set
       @expectations.to_set
     end
-
+    
     def length
       @expectations.length
     end
-
+    
   end
 
 end

data/lib/mocha/in_state_ordering_constraint.rb

@@ -0,0 +1,19 @@
+module Mocha
+
+  class InStateOrderingConstraint
+  
+    def initialize(state_predicate)
+      @state_predicate = state_predicate
+    end
+  
+    def allows_invocation_now?
+      @state_predicate.active?
+    end
+  
+    def mocha_inspect
+      "when #{@state_predicate.mocha_inspect}"
+    end
+  
+  end
+
+end

data/lib/mocha/instance_method.rb

@@ -3,6 +3,15 @@ require 'mocha/class_method'
 module Mocha
 
   class InstanceMethod < ClassMethod
+
+    def method_exists?(method)
+      existing_methods = []
+      existing_methods += stubbee.public_methods(false)
+      existing_methods += stubbee.protected_methods(false)
+      existing_methods += stubbee.private_methods(false)
+      existing_methods.any? { |m| m.to_s == method.to_s }
+    end
+
   end
   
 end