mocha 0.5.5 → 0.5.6

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 require 'rake/contrib/sshpublisher'
 
 module Mocha
-  VERSION = "0.5.5"
+  VERSION = "0.5.6"
 end
 
 desc "Run all tests"
@@ -96,6 +96,7 @@ specification = Gem::Specification.new do |s|
   s.name   = "mocha"
   s.summary = "Mocking and stubbing library"
   s.version = Mocha::VERSION
+  s.platform = Gem::Platform::RUBY
   s.author = 'James Mead'
   s.description = <<-EOF
     Mocking and stubbing library with JMock/SchMock syntax, which allows mocking and stubbing of methods on real (non-mock) classes.
@@ -109,6 +110,7 @@ specification = Gem::Specification.new do |s|
   s.rdoc_options << '--title' << 'Mocha' << '--main' << 'README' << '--line-numbers'
                          
   s.autorequire = 'mocha'
+  s.add_dependency('rake')
   s.files = FileList['{lib,test,examples}/**/*.rb', '[A-Z]*'].exclude('TODO').to_a
 end
 

data/examples/misc.rb

@@ -1,36 +1,44 @@
-# Mocking a class method
-
-  product = Product.new
-  Product.expects(:find).with(1).returns(product)
-  assert_equal product, Product.find(1)
-
-# Mocking an instance method on a real object
-
-  product = Product.new
-  product.expects(:save).returns(true)
-  assert product.save
-
-# Stubbing instance methods on real object
-
-  prices = [stub(:pence => 1000), stub(:pence => 2000)]
-  product = Product.new
-  product.stubs(:prices).returns(prices)
-  assert_equal [1000, 2000], product.prices.collect {|p| p.pence}
-
-# Stubbing an instance method on all instances of a class
-
-  Product.any_instance.stubs(:name).returns('stubbed_name')
-  product = Product.new
-  assert_equal 'stubbed_name', product.name
-
-# Traditional mocking
-
-  object = mock()
-  object.expects(:expected_method).with(:p1, :p2).returns(:result)
-  assert_equal :result, object.expected_method(:p1, :p2)
-
-# Shortcuts
-
-  object = stub(:method1 => :result1, :method2 => :result2)
-  assert_equal :result1, object.method1
-  assert_equal :result2, object.method2
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+class MiscExampleTest < Test::Unit::TestCase
+  
+  def test_mocking_a_class_method
+    product = Product.new
+    Product.expects(:find).with(1).returns(product)
+    assert_equal product, Product.find(1)
+  end
+
+  def test_mocking_an_instance_method_on_a_real_object
+    product = Product.new
+    product.expects(:save).returns(true)
+    assert product.save
+  end
+
+  def test_stubbing_instance_methods_on_real_objects
+    prices = [stub(:pence => 1000), stub(:pence => 2000)]
+    product = Product.new
+    product.stubs(:prices).returns(prices)
+    assert_equal [1000, 2000], product.prices.collect {|p| p.pence}
+  end
+
+  def test_stubbing_an_instance_method_on_all_instances_of_a_class
+    Product.any_instance.stubs(:name).returns('stubbed_name')
+    product = Product.new
+    assert_equal 'stubbed_name', product.name
+  end
+
+  def test_traditional_mocking
+    object = mock()
+    object.expects(:expected_method).with(:p1, :p2).returns(:result)
+    assert_equal :result, object.expected_method(:p1, :p2)
+  end
+
+  def test_shortcuts
+    object = stub(:method1 => :result1, :method2 => :result2)
+    assert_equal :result1, object.method1
+    assert_equal :result2, object.method2
+  end
+  
+end

data/examples/stubba.rb

@@ -21,7 +21,7 @@ class Order
     end
   
     def number_shipped_since(date)
-      find_all.select { |order| order.shipped_on > date }.size
+      find_all.select { |order| order.shipped_on > date }.length
     end
 
     def unshipped_value

data/lib/mocha/auto_verify.rb

@@ -1,4 +1,5 @@
 require 'mocha/mock'
+require 'mocha/sequence'
 
 module Mocha # :nodoc:
   
@@ -17,9 +18,9 @@ module Mocha # :nodoc:
       @mocks = nil
     end
     
-    # :call-seq: mock(name) -> mock object
-    #            mock(expected_methods = {}) -> mock object
-    #            mock(name, expected_methods = {}) -> mock object
+    # :call-seq: mock(name, &block) -> mock object
+    #            mock(expected_methods = {}, &block) -> mock object
+    #            mock(name, expected_methods = {}, &block) -> mock object
     #
     # Creates a mock object.
     #
@@ -27,6 +28,8 @@ module Mocha # :nodoc:
     #
     # +expected_methods+ is a +Hash+ with expected method name symbols as keys and corresponding return values as values.
     #
+    # +block+ is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #
     # Note that (contrary to expectations set up by #stub) these expectations <b>must</b> be fulfilled during the test.
     #   def test_product
     #     product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
@@ -34,17 +37,18 @@ module Mocha # :nodoc:
     #     assert_equal 100, product.price
     #     # an error will be raised unless both Product#manufacturer and Product#price have been called
     #   end 
-    def mock(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      mock = Mock.new(false, name)
+    def mock(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      mock = Mock.new(name, &block)
       mock.expects(expectations)
       mocks << mock
       mock
     end
   
-    # :call-seq: stub(name) -> mock object
-    #            stub(stubbed_methods = {}) -> mock object
-    #            stub(name, stubbed_methods = {}) -> mock object
+    # :call-seq: stub(name, &block) -> mock object
+    #            stub(stubbed_methods = {}, &block) -> mock object
+    #            stub(name, stubbed_methods = {}, &block) -> mock object
     #
     # Creates a mock object.
     #
@@ -52,6 +56,8 @@ module Mocha # :nodoc:
     #
     # +stubbed_methods+ is a +Hash+ with stubbed method name symbols as keys and corresponding return values as values.
     #
+    # +block+ is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #
     # Note that (contrary to expectations set up by #mock) these expectations <b>need not</b> be fulfilled during the test.
     #   def test_product
     #     product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
@@ -59,22 +65,25 @@ module Mocha # :nodoc:
     #     assert_equal 100, product.price
     #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
     #   end
-    def stub(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      mock = Mock.new(false, name)
-      mock.stubs(expectations)
-      mocks << mock
-      mock
+    def stub(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      stub = Mock.new(name, &block)
+      stub.stubs(expectations)
+      mocks << stub
+      stub
     end
   
-    # :call-seq: stub_everything(name) -> mock object
-    #            stub_everything(stubbed_methods = {}) -> mock object
-    #            stub_everything(name, stubbed_methods = {}) -> mock object
+    # :call-seq: stub_everything(name, &block) -> mock object
+    #            stub_everything(stubbed_methods = {}, &block) -> mock object
+    #            stub_everything(name, stubbed_methods = {}, &block) -> mock object
     #
     # Creates a mock object that accepts calls to any method.
     #
     # By default it will return +nil+ for any method call.
     #
+    # +block+ is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.
+    #
     # +name+ and +stubbed_methods+ work in the same way as for #stub.
     #   def test_product
     #     product = stub_everything('ipod_product', :price => 100)
@@ -82,12 +91,14 @@ module Mocha # :nodoc:
     #     assert_nil product.any_old_method
     #     assert_equal 100, product.price
     #   end
-    def stub_everything(*args)
-      name, expectations = name_and_expectations_from_args(args)
-      mock = Mock.new(true, name)
-      mock.stubs(expectations)
-      mocks << mock
-      mock
+    def stub_everything(*arguments, &block)
+      name = arguments.shift if arguments.first.is_a?(String)
+      expectations = arguments.shift || {}
+      stub = Mock.new(name, &block)
+      stub.stub_everything
+      stub.stubs(expectations)
+      mocks << stub
+      stub
     end
     
     def verify_mocks # :nodoc:
@@ -97,13 +108,9 @@ module Mocha # :nodoc:
     def teardown_mocks # :nodoc:
       reset_mocks
     end
-  
-  private
-
-    def name_and_expectations_from_args(args) # :nodoc:
-      name = args.first.is_a?(String) ? args.delete_at(0) : nil
-      expectations = args.first || {}
-      [name, expectations]
+    
+    def sequence(name) # :nodoc:
+      Sequence.new(name)
     end
   
   end

data/lib/mocha/central.rb

@@ -24,7 +24,7 @@ module Mocha
     end
   
     def unstub_all
-      while stubba_methods.size > 0
+      while stubba_methods.length > 0
         method = stubba_methods.pop
         method.unstub
       end

data/lib/mocha/class_method.rb

@@ -42,7 +42,11 @@ module Mocha
     end
   
     def hidden_method
-      method_name = method.to_s.gsub(/\W/) {|s| "_substituted_character_#{s[0]}_" }
+      if RUBY_VERSION < '1.9'
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s[0]}_" }
+      else
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s.ord}_" }
+      end
       "__stubba__#{method_name}__stubba__"
     end  
   

data/lib/mocha/expectation.rb

@@ -1,5 +1,6 @@
 require 'mocha/infinite_range'
-require 'mocha/pretty_parameters'
+require 'mocha/method_matcher'
+require 'mocha/parameters_matcher'
 require 'mocha/expectation_error'
 require 'mocha/return_values'
 require 'mocha/exception_raiser'
@@ -11,46 +12,6 @@ module Mocha # :nodoc:
   # Methods on expectations returned from Mock#expects, Mock#stubs, Object#expects and Object#stubs.
   class Expectation
   
-    # :stopdoc:
-    
-    class AlwaysEqual
-      def ==(other)
-        true
-      end
-    end
-  
-    attr_reader :method_name, :backtrace
-
-    def initialize(mock, method_name, backtrace = nil)
-      @mock, @method_name = mock, method_name
-      @expected_count = 1
-      @parameters, @parameter_block = AlwaysEqual.new, nil
-      @invoked_count, @return_values = 0, ReturnValues.new
-      @backtrace = backtrace || caller
-      @yield_parameters = YieldParameters.new
-      @final_expectation = false
-    end
-    
-    def match?(method_name, *arguments)
-      return false unless @method_name == method_name
-      if @parameter_block then
-        return false unless @parameter_block.call(*arguments)
-      else
-        return false unless (@parameters == arguments)
-      end
-      return true
-    end
-    
-    def invocations_allowed?
-      if @expected_count.is_a?(Range) then
-        @invoked_count < @expected_count.last
-      else
-        @invoked_count < @expected_count
-      end
-    end
-
-    # :startdoc:
-    
     # :call-seq: times(range) -> expectation
     #
     # Modifies expectation so that the number of calls to the expected method must be within a specific +range+.
@@ -187,9 +148,9 @@ module Mocha # :nodoc:
       self
     end
   
-    # :call-seq: with(*arguments, &parameter_block) -> expectation
+    # :call-seq: with(*expected_parameters, &matching_block) -> expectation
     #
-    # Modifies expectation so that the expected method must be called with specified +arguments+.
+    # Modifies expectation so that the expected method must be called with +expected_parameters+.
     #   object = mock()
     #   object.expects(:expected_method).with(:param1, :param2)
     #   object.expected_method(:param1, :param2)
@@ -201,7 +162,7 @@ module Mocha # :nodoc:
     #   # => verify fails
     # May be used with parameter matchers in Mocha::ParameterMatchers.
     #
-    # If a +parameter_block+ is given, the block is called with the parameters passed to the expected method.
+    # If a +matching_block+ is given, the block is called with the parameters passed to the expected method.
     # The expectation is matched if the block evaluates to +true+.
     #   object = mock()
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
@@ -212,9 +173,8 @@ module Mocha # :nodoc:
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
     #   object.expected_method(17)
     #   # => verify fails
-    def with(*arguments, &parameter_block)
-      @parameters, @parameter_block = arguments, parameter_block
-      class << @parameters; def to_s; join(', '); end; end
+    def with(*expected_parameters, &matching_block)
+      @parameters_matcher = ParametersMatcher.new(expected_parameters, &matching_block)
       self
     end
   
@@ -263,7 +223,7 @@ module Mocha # :nodoc:
     end
     
     # :call-seq: returns(value) -> expectation
-    # :call-seq: returns(*values) -> expectation
+    #            returns(*values) -> expectation
     #
     # Modifies expectation so that when the expected method is called, it returns the specified +value+.
     #   object = mock()
@@ -339,6 +299,56 @@ module Mocha # :nodoc:
     
     # :stopdoc:
     
+    def in_sequence(*sequences)
+      sequences.each { |sequence| sequence.constrain_as_next_in_sequence(self) }
+      self
+    end
+    
+    attr_reader :backtrace
+
+    def initialize(mock, expected_method_name, backtrace = nil)
+      @mock = mock
+      @method_matcher = MethodMatcher.new(expected_method_name)
+      @parameters_matcher = ParametersMatcher.new
+      @ordering_constraints = []
+      @expected_count, @invoked_count = 1, 0
+      @return_values = ReturnValues.new
+      @yield_parameters = YieldParameters.new
+      @backtrace = backtrace || caller
+    end
+    
+    def add_ordering_constraint(ordering_constraint)
+      @ordering_constraints << ordering_constraint
+    end
+    
+    def in_correct_order?
+      @ordering_constraints.all? { |ordering_constraint| ordering_constraint.allows_invocation_now? }
+    end
+    
+    def matches_method?(method_name)
+      @method_matcher.match?(method_name)
+    end
+    
+    def match?(actual_method_name, *actual_parameters)
+      @method_matcher.match?(actual_method_name) && @parameters_matcher.match?(actual_parameters) && in_correct_order?
+    end
+    
+    def invocations_allowed?
+      if @expected_count.is_a?(Range) then
+        @invoked_count < @expected_count.last
+      else
+        @invoked_count < @expected_count
+      end
+    end
+
+    def satisfied?
+      if @expected_count.is_a?(Range) then
+        @invoked_count >= @expected_count.first
+      else
+        @invoked_count >= @expected_count
+      end
+    end
+  
     def invoke
       @invoked_count += 1
       if block_given? then
@@ -352,27 +362,19 @@ module Mocha # :nodoc:
     def verify
       yield(self) if block_given?
       unless (@expected_count === @invoked_count) then
-        error = ExpectationError.new(error_message(@expected_count, @invoked_count))
-        error.set_backtrace(filtered_backtrace)
+        error = ExpectationError.new(error_message(@expected_count, @invoked_count), backtrace)
         raise error
       end
     end
     
-    def mocha_lib_directory
-      File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
-    end
-    
-    def filtered_backtrace
-      backtrace.reject { |location| Regexp.new(mocha_lib_directory).match(File.expand_path(location)) }
-    end
-  
     def method_signature
-      return "#{method_name}" if @parameters.__is_a__(AlwaysEqual)
-      "#{@method_name}(#{PrettyParameters.new(@parameters).pretty})"
+      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
     end
     
     def error_message(expected_count, actual_count)
-      "#{@mock.mocha_inspect}.#{method_signature} - expected calls: #{expected_count.mocha_inspect}, actual calls: #{actual_count}"
+      "#{method_signature} - expected calls: #{expected_count.mocha_inspect}, actual calls: #{actual_count}"
     end
   
     # :startdoc: