mocha 0.9.0 → 0.9.1

data/RELEASE

@@ -1,4 +1,17 @@
-= 0.9.0
+= 0.9.1 (r349)
+
+* Fixed bug #21465 - expects & stubs should support method names as strings (as well as symbols) or fail fast. Convert all expectation method names to a symbol in case they were supplied as a string.
+* By removing Mock#unexpected_method_called we reduce the number of methods vulnerable to the problem that surfaced in bug #21563.
+* Fix bug #21563 - stubbing 'verified?' method is unsafe. Instance method names on the Mock class should be more obscure.
+* Performance improvement. StubbaExampleTest goes twice as fast on my local machine.
+* Added primitive performance test to default rake task.
+* Fix format of case statements which don't work in Ruby 1.9 and make others consistent.
+* There is no point in running (potentially expensive) checks if configuration is set to allow such checks to fail. This is a relatively quick fix in response to Chris McGrath's performance problems.
+* Fix for bug #21161 - 'uninitialized constant Deprecation in stubba.rb'.
+* It's more readable to talk about 'once' and 'twice' rather than '1 time' and '2 times'.
+* Fix bug #20883 - never should raise when called to prevent follow up errors. Fail fast when there are no matching invokable expectations and handle the stub_everything case sensibly. This might not be entirely backwards compatible, but I think the benefits outweigh the risks. The most likely change is that a test that was already failing will now fail faster, which doesn't seem so awful.
+
+= 0.9.0 (r316)
 
 * Configurable warnings or errors
   * when a method on a non-public method is stubbed

data/Rakefile

@@ -5,11 +5,11 @@ require 'rake/testtask'
 require 'rake/contrib/sshpublisher'
 
 module Mocha
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end
 
 desc "Run all tests"
-task 'default' => ['test:units', 'test:acceptance']
+task 'default' => ['test:units', 'test:acceptance', 'test:performance']
 
 namespace 'test' do
   
@@ -42,6 +42,23 @@ namespace 'test' do
   #   t.rcov_opts << '--xref'
   # end
 
+  desc "Run performance tests"
+  task 'performance' do
+    require 'test/acceptance/stubba_example_test'
+    require 'test/acceptance/mocha_example_test'
+    iterations = 1000
+    puts "\nBenchmarking with #{iterations} iterations..."
+    [MochaExampleTest, StubbaExampleTest].each do |test_case|
+      puts "#{test_case}: #{benchmark_test_case(test_case, iterations)} seconds."
+    end
+  end
+
+end
+
+def benchmark_test_case(klass, iterations)
+  require 'test/unit/ui/console/testrunner'
+  require 'benchmark'
+  time = Benchmark.realtime { iterations.times { Test::Unit::UI::Console::TestRunner.run(klass, Test::Unit::UI::SILENT) } }
 end
 
 desc 'Generate RDoc'

data/lib/mocha/any_instance_method.rb

@@ -43,11 +43,10 @@ module Mocha
     end
 
     def method_exists?(method)
-      existing_methods = []
-      existing_methods += stubbee.public_instance_methods(false)
-      existing_methods += stubbee.protected_instance_methods(false)
-      existing_methods += stubbee.private_instance_methods(false)
-      existing_methods.any? { |m| m.to_s == method.to_s }
+      return true if stubbee.public_instance_methods(false).include?(method)
+      return true if stubbee.protected_instance_methods(false).include?(method)
+      return true if stubbee.private_instance_methods(false).include?(method)
+      return false
     end
     
   end

data/lib/mocha/cardinality.rb

@@ -20,10 +20,8 @@ module Mocha
       
       def times(range_or_count)
         case range_or_count
-        when Range
-          new(range_or_count.first, range_or_count.last)
-        else
-          new(range_or_count, range_or_count)
+          when Range then new(range_or_count.first, range_or_count.last)
+          else new(range_or_count, range_or_count)
         end
       end
       
@@ -80,7 +78,12 @@ module Mocha
     attr_reader :required, :maximum
     
     def times(number)
-      number == 1 ? "once" : "#{number} times"
+      case number
+        when 0 then "no times"
+        when 1 then "once"
+        when 2 then "twice"
+        else "#{number} times"
+      end
     end
     
     def infinite?(number)

data/lib/mocha/class_method.rb

@@ -7,7 +7,8 @@ module Mocha
     attr_reader :stubbee, :method
    
     def initialize(stubbee, method)
-      @stubbee, @method = stubbee, method
+      @stubbee = stubbee
+      @method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
     end
   
     def stub
@@ -59,7 +60,8 @@ module Mocha
       else
         method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s.ord}_" }
       end
-      "__stubba__#{method_name}__stubba__"
+      hidden_method = "__stubba__#{method_name}__stubba__"
+      RUBY_VERSION < '1.9' ? hidden_method.to_s : hidden_method.to_sym
     end  
   
     def eql?(other)
@@ -74,13 +76,11 @@ module Mocha
     end
     
     def method_exists?(method)
-      existing_methods = []
-      existing_methods += stubbee.public_methods(true) - stubbee.superclass.public_methods(true)
-      existing_methods += stubbee.protected_methods(true) - stubbee.superclass.protected_methods(true)
-      existing_methods += stubbee.private_methods(true) - stubbee.superclass.private_methods(true)
-      existing_methods.any? { |m| m.to_s == method.to_s }
+      symbol = method.to_sym
+      metaclass = stubbee.__metaclass__
+      metaclass.public_method_defined?(symbol) || metaclass.protected_method_defined?(symbol) || metaclass.private_method_defined?(symbol)
     end
 
   end
   
-end
+end

data/lib/mocha/expectation.rb

@@ -354,7 +354,7 @@ module Mocha # :nodoc:
 
     def initialize(mock, expected_method_name, backtrace = nil)
       @mock = mock
-      @method_matcher = MethodMatcher.new(expected_method_name)
+      @method_matcher = MethodMatcher.new(expected_method_name.to_sym)
       @parameters_matcher = ParametersMatcher.new
       @ordering_constraints = []
       @side_effects = []
@@ -422,11 +422,11 @@ module Mocha # :nodoc:
     
     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"
+      message << case @invocation_count
+        when 0 then "not yet invoked"
+        when 1 then "already invoked once"
+        when 2 then "already invoked twice"
+        else "already invoked #{@invocation_count} times"
       end
       message << ": "
       message << method_signature

data/lib/mocha/expectation_list.rb

@@ -7,7 +7,7 @@ module Mocha # :nodoc:
     end
     
     def add(expectation)
-      @expectations << expectation
+      @expectations.unshift(expectation)
       expectation
     end
     
@@ -15,10 +15,12 @@ module Mocha # :nodoc:
       @expectations.any? { |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
+    def match(method_name, *arguments)
+      matching_expectations(method_name, *arguments).first
+    end
+    
+    def match_allowing_invocation(method_name, *arguments)
+      matching_expectations(method_name, *arguments).detect { |e| e.invocations_allowed? }
     end
     
     def verified?(assertion_counter = nil)
@@ -37,6 +39,12 @@ module Mocha # :nodoc:
       @expectations.length
     end
     
+    private
+    
+    def matching_expectations(method_name, *arguments)
+      @expectations.select { |e| e.match?(method_name, *arguments) }
+    end
+    
   end
 
 end

data/lib/mocha/instance_method.rb

@@ -5,11 +5,10 @@ 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 }
+      return true if stubbee.public_methods(false).include?(method)
+      return true if stubbee.protected_methods(false).include?(method)
+      return true if stubbee.private_methods(false).include?(method)
+      return false
     end
 
   end

data/lib/mocha/mock.rb

@@ -5,6 +5,7 @@ require 'mocha/names'
 require 'mocha/mockery'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
+require 'mocha/unexpected_invocation'
 
 module Mocha # :nodoc:
   
@@ -145,10 +146,6 @@ module Mocha # :nodoc:
     
     alias_method :quacks_like, :responds_like
 
-    def add_expectation(expectation)
-      @expectations.add(expectation)
-    end
-    
     def stub_everything
       @everything_stubbed = true
     end
@@ -157,13 +154,14 @@ module Mocha # :nodoc:
       if @responder and not @responder.respond_to?(symbol)
         raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
       end
-      matching_expectation = @expectations.detect(symbol, *arguments)
-      if matching_expectation then
-        matching_expectation.invoke(&block)
-      elsif @everything_stubbed then
-        return
+      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
+        matching_expectation_allowing_invocation.invoke(&block)
       else
-        unexpected_method_called(symbol, *arguments)
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
       end
     end
     
@@ -175,16 +173,7 @@ module Mocha # :nodoc:
       end
     end
     
-    def unexpected_method_called(symbol, *arguments)
-      method_matcher = MethodMatcher.new(symbol)
-      parameters_matcher = ParametersMatcher.new(arguments)
-      method_signature = "#{mocha_inspect}.#{method_matcher.mocha_inspect}#{parameters_matcher.mocha_inspect}"
-      message = "unexpected invocation: #{method_signature}\n"
-      message << Mockery.instance.mocha_inspect
-      raise ExpectationError.new(message, caller)
-    end
-    
-    def verified?(assertion_counter = nil)
+    def __verified__?(assertion_counter = nil)
       @expectations.verified?(assertion_counter)
     end
     

data/lib/mocha/mockery.rb

@@ -43,7 +43,7 @@ module Mocha
     end
     
     def verify(assertion_counter = nil)
-      unless mocks.all? { |mock| mock.verified?(assertion_counter) }
+      unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
         message = "not all expectations were satisfied\n#{mocha_inspect}"
         if unsatisfied_expectations.empty?
           backtrace = caller
@@ -53,7 +53,11 @@ module Mocha
         raise ExpectationError.new(message, backtrace)
       end
       expectations.each do |e|
-        on_stubbing_method_unnecessarily(e) unless e.used?
+        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+          unless e.used?
+            on_stubbing_method_unnecessarily(e)
+          end
+        end
       end
     end
     
@@ -82,36 +86,47 @@ module Mocha
       message
     end
     
-    def on_stubbing(object, symbol)
-      on_stubbing_non_existent_method(object, symbol) unless object.method_exists?(symbol, include_public_methods = true)
-      on_stubbing_non_public_method(object, symbol) if object.method_exists?(symbol, include_public_methods = false)
-      on_stubbing_method_on_non_mock_object(object, symbol)
+    def on_stubbing(object, method)
+      method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
+      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
+        unless object.method_exists?(method, include_public_methods = true)
+          on_stubbing_non_existent_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
+        if object.method_exists?(method, include_public_methods = false)
+          on_stubbing_non_public_method(object, method)
+        end
+      end
+      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
+        on_stubbing_method_on_non_mock_object(object, method)
+      end
     end
     
-    def on_stubbing_non_existent_method(object, symbol)
+    def on_stubbing_non_existent_method(object, method)
       if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
-        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{symbol}", caller)
+        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
       end
       if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{symbol}"
+        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
       end
     end
     
-    def on_stubbing_non_public_method(object, symbol)
+    def on_stubbing_non_public_method(object, method)
       if Mocha::Configuration.prevent?(:stubbing_non_public_method)
-        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{symbol}", caller)
+        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
       end
       if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{symbol}"
+        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
       end
     end
     
-    def on_stubbing_method_on_non_mock_object(object, symbol)
+    def on_stubbing_method_on_non_mock_object(object, method)
       if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
-        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{symbol}", caller)
+        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
       end
       if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{symbol}"
+        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
       end
     end
     

data/lib/mocha/module_method.rb

@@ -5,11 +5,10 @@ module Mocha
   class ModuleMethod < 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 }
+      return true if stubbee.public_methods(false).include?(method)
+      return true if stubbee.protected_methods(false).include?(method)
+      return true if stubbee.private_methods(false).include?(method)
+      return false
     end
 
   end

data/lib/mocha/object.rb

@@ -63,10 +63,14 @@ class Object
     mocha.stubs(symbol, caller)
   end
   
-  def method_exists?(symbol, include_public_methods = true)
-    existing_methods = private_methods(include_superclass_methods = true) + protected_methods(include_superclass_methods = true)
-    existing_methods += public_methods(include_superclass_methods = true) if include_public_methods
-    existing_methods.any? { |m| m.to_s == symbol.to_s } || (respond_to?(symbol) && include_public_methods)
+  def method_exists?(method, include_public_methods = true)
+    if include_public_methods
+      return true if public_methods(include_superclass_methods = true).include?(method)
+      return true if respond_to?(method)
+    end
+    return true if protected_methods(include_superclass_methods = true).include?(method)
+    return true if private_methods(include_superclass_methods = true).include?(method)
+    return false
   end
   
 end
@@ -103,10 +107,13 @@ class Class
       @stubba_object
     end
     
-    def method_exists?(symbol, include_public_methods = true)
-      existing_methods = @stubba_object.private_instance_methods(include_superclass_methods = true) + @stubba_object.protected_instance_methods(include_superclass_methods = true)
-      existing_methods += @stubba_object.public_instance_methods(include_superclass_methods = true) if include_public_methods
-      existing_methods.any? { |m| m.to_s == symbol.to_s }
+    def method_exists?(method, include_public_methods = true)
+      if include_public_methods
+        return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+      end
+      return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
+      return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
+      return false
     end
     
   end

data/lib/mocha/return_values.rb

@@ -16,12 +16,9 @@ module Mocha # :nodoc:
     
     def next
       case @values.length
-        when 0
-          nil
-        when 1
-          @values.first.evaluate
-        else
-          @values.shift.evaluate
+        when 0 then nil
+        when 1 then @values.first.evaluate
+        else @values.shift.evaluate
       end
     end
     

data/lib/mocha/unexpected_invocation.rb

@@ -0,0 +1,18 @@
+module Mocha # :nodoc:
+
+  class UnexpectedInvocation
+    
+    def initialize(mock, symbol, *arguments)
+      @mock = mock
+      @method_matcher = MethodMatcher.new(symbol)
+      @parameters_matcher = ParametersMatcher.new(arguments)
+    end
+    
+    def to_s
+      method_signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+      "unexpected invocation: #{method_signature}\n"
+    end
+    
+  end
+  
+end

data/lib/mocha/yield_parameters.rb

@@ -12,9 +12,9 @@ module Mocha # :nodoc:
     
     def next_invocation
       case @parameter_groups.length
-      when 0; NoYields.new
-      when 1; @parameter_groups.first
-      else @parameter_groups.shift
+        when 0 then NoYields.new
+        when 1 then @parameter_groups.first
+        else @parameter_groups.shift
       end
     end
     

data/lib/stubba.rb

@@ -1,3 +1,4 @@
 # for backwards compatibility
 require 'mocha'
-Deprecation.warning "require 'stubba' is no longer needed and stubba.rb will soon be removed"
+require 'mocha/deprecation'
+Mocha::Deprecation.warning "require 'stubba' is no longer needed and stubba.rb will soon be removed"

data/test/acceptance/bug_21465_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug21563Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_expected_method_name_to_be_a_string
+    test_result = run_test do
+      mock = mock()
+      mock.expects('wibble')
+      mock.wibble
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_allow_stubbed_method_name_to_be_a_string
+    test_result = run_test do
+      mock = mock()
+      mock.stubs('wibble')
+      mock.wibble
+    end
+    assert_passed(test_result)
+  end
+  
+end

data/test/acceptance/bug_21563_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug21563Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  def test_should_allow_stubbing_of_verified_method
+    test_result = run_test do
+      object = Object.new
+      object.stubs(:verified?).returns(false)
+      assert !object.verified?
+    end
+    assert_passed(test_result)
+  end
+  
+end

data/test/acceptance/expected_invocation_count_test.rb

@@ -22,14 +22,14 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
     assert_passed(test_result)
   end
   
-  def test_should_fail_if_method_is_never_expected_but_is_called_once
+  def test_should_fail_fast_if_method_is_never_expected_but_is_called_once
     test_result = run_test do
       mock = mock('mock')
       mock.expects(:method).never
       1.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected never, already invoked 1 time: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nsatisfied expectations:\n- expected never, not yet invoked: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
   def test_should_pass_if_method_is_expected_twice_and_is_called_twice
@@ -48,17 +48,17 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
       1.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected exactly 2 times, already invoked 1 time: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected exactly twice, already invoked once: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
-  def test_should_fail_if_method_is_expected_twice_but_is_called_three_times
+  def test_should_fail_fast_if_method_is_expected_twice_but_is_called_three_times
     test_result = run_test do
       mock = mock('mock')
       mock.expects(:method).times(2)
       3.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected exactly 2 times, already invoked 3 times: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nsatisfied expectations:\n- expected exactly twice, already invoked twice: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
   def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_twice
@@ -95,17 +95,17 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
       1.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected between 2 and 4 times, already invoked 1 time: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected between 2 and 4 times, already invoked once: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
 
-  def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
+  def test_should_fail_fast_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
     test_result = run_test do
       mock = mock('mock')
       mock.expects(:method).times(2..4)
       5.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected between 2 and 4 times, already invoked 5 times: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nsatisfied expectations:\n- expected between 2 and 4 times, already invoked 4 times: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
   def test_should_pass_if_method_is_expected_at_least_once_and_is_called_once
@@ -133,7 +133,7 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
       0.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected at least once, never invoked: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected at least once, not yet invoked: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
   def test_should_pass_if_method_is_expected_at_most_once_and_is_never_called
@@ -154,14 +154,14 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
     assert_passed(test_result)
   end
   
-  def test_should_fail_if_method_is_expected_at_most_once_but_is_called_twice
+  def test_should_fail_fast_if_method_is_expected_at_most_once_but_is_called_twice
     test_result = run_test do
       mock = mock('mock')
       mock.expects(:method).at_most_once
       2.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected at most once, already invoked 2 times: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nsatisfied expectations:\n- expected at most once, already invoked once: #<Mock:mock>.method(any_parameters)\n"], test_result.failure_messages
   end
   
   def test_should_pass_if_method_is_never_expected_and_is_never_called_even_if_everything_is_stubbed
@@ -173,24 +173,24 @@ class ExpectedInvocationCountTest < Test::Unit::TestCase
     assert_passed(test_result)
   end
   
-  def test_should_fail_if_method_is_never_expected_but_is_called_once_even_if_everything_is_stubbed
+  def test_should_fail_fast_if_method_is_never_expected_but_is_called_once_even_if_everything_is_stubbed
     test_result = run_test do
       stub = stub_everything('stub')
       stub.expects(:method).never
       1.times { stub.method }
     end
     assert_failed(test_result)
-    assert_equal ["not all expectations were satisfied\nunsatisfied expectations:\n- expected never, already invoked 1 time: #<Mock:stub>.method(any_parameters)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:stub>.method()\nsatisfied expectations:\n- expected never, not yet invoked: #<Mock:stub>.method(any_parameters)\n"], test_result.failure_messages
   end
   
-  def test_should_fail_if_there_is_no_matching_expectation
+  def test_should_fail_fast_if_there_is_no_matching_expectation
     test_result = run_test do
       mock = mock('mock')
       mock.expects(:method).with(1)
       1.times { mock.method }
     end
     assert_failed(test_result)
-    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nunsatisfied expectations:\n- expected exactly once, never invoked: #<Mock:mock>.method(1)\n"], test_result.failure_messages
+    assert_equal ["unexpected invocation: #<Mock:mock>.method()\nunsatisfied expectations:\n- expected exactly once, not yet invoked: #<Mock:mock>.method(1)\n"], test_result.failure_messages
   end
   
 end

data/test/acceptance/stubba_test.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'deprecation_disabler'
+
+class StubbaTest < Test::Unit::TestCase
+
+  include DeprecationDisabler
+
+  def test_should_report_deprecation_of_stubba_which_will_be_removed_in_a_future_release
+    disable_deprecations do
+      load 'stubba.rb'
+    end
+    assert_equal ["require 'stubba' is no longer needed and stubba.rb will soon be removed"], Mocha::Deprecation.messages
+  end
+
+end

data/test/unit/any_instance_method_test.rb

@@ -43,7 +43,7 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     result = instance.method_x(:param1, :param2)
         
     assert_equal :result, result
-    assert mocha.verified?
+    assert mocha.__verified__?
   end
 
   def test_should_restore_original_method

data/test/unit/cardinality_test.rb

@@ -25,16 +25,16 @@ class CardinalityTest < Test::Unit::TestCase
     assert_equal 'allowed any number of times', Cardinality.at_least(0).mocha_inspect
     
     assert_equal 'expected at most once', Cardinality.at_most(1).mocha_inspect
-    assert_equal 'expected at most 2 times', Cardinality.at_most(2).mocha_inspect
+    assert_equal 'expected at most twice', Cardinality.at_most(2).mocha_inspect
     assert_equal 'expected at most 3 times', Cardinality.at_most(3).mocha_inspect
     
     assert_equal 'expected at least once', Cardinality.at_least(1).mocha_inspect
-    assert_equal 'expected at least 2 times', Cardinality.at_least(2).mocha_inspect
+    assert_equal 'expected at least twice', Cardinality.at_least(2).mocha_inspect
     assert_equal 'expected at least 3 times', Cardinality.at_least(3).mocha_inspect
     
     assert_equal 'expected never', Cardinality.exactly(0).mocha_inspect
     assert_equal 'expected exactly once', Cardinality.exactly(1).mocha_inspect
-    assert_equal 'expected exactly 2 times', Cardinality.exactly(2).mocha_inspect
+    assert_equal 'expected exactly twice', Cardinality.exactly(2).mocha_inspect
     assert_equal 'expected exactly 3 times', Cardinality.times(3).mocha_inspect
     
     assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).mocha_inspect

data/test/unit/central_test.rb

@@ -21,7 +21,7 @@ class CentralTest < Test::Unit::TestCase
     
     stubba.stub(method)
     
-    assert method.verified?
+    assert method.__verified__?
   end
   
   def test_should_not_stub_method_if_already_stubbed
@@ -34,7 +34,7 @@ class CentralTest < Test::Unit::TestCase
     
     stubba.stub(method)
     
-    assert method.verified?
+    assert method.__verified__?
   end
   
   def test_should_record_method
@@ -58,8 +58,8 @@ class CentralTest < Test::Unit::TestCase
     stubba.unstub_all
     
     assert_equal [], stubba.stubba_methods
-    assert method_1.verified?
-    assert method_2.verified?
+    assert method_1.__verified__?
+    assert method_2.__verified__?
   end
   
 end

data/test/unit/class_method_test.rb

@@ -10,47 +10,47 @@ class ClassMethodTest < Test::Unit::TestCase
 
   def test_should_provide_hidden_version_of_method_name_starting_with_prefix
     method = ClassMethod.new(nil, :original_method_name)
-    assert_match(/^__stubba__/, method.hidden_method)
+    assert_match(/^__stubba__/, method.hidden_method.to_s)
   end
   
   def test_should_provide_hidden_version_of_method_name_ending_with_suffix
     method = ClassMethod.new(nil, :original_method_name)
-    assert_match(/__stubba__$/, method.hidden_method)
+    assert_match(/__stubba__$/, method.hidden_method.to_s)
   end
   
   def test_should_provide_hidden_version_of_method_name_including_original_method_name
     method = ClassMethod.new(nil, :original_method_name)
-    assert_match(/original_method_name/, method.hidden_method)
+    assert_match(/original_method_name/, method.hidden_method.to_s)
   end
   
   def test_should_provide_hidden_version_of_method_name_substituting_question_mark
     method = ClassMethod.new(nil, :question_mark?)
-    assert_no_match(/\?/, method.hidden_method)
-    assert_match(/question_mark_substituted_character_63/, method.hidden_method)
+    assert_no_match(/\?/, method.hidden_method.to_s)
+    assert_match(/question_mark_substituted_character_63/, method.hidden_method.to_s)
   end
   
   def test_should_provide_hidden_version_of_method_name_substituting_exclamation_mark
     method = ClassMethod.new(nil, :exclamation_mark!)
-    assert_no_match(/!/, method.hidden_method)
-    assert_match(/exclamation_mark_substituted_character_33/, method.hidden_method)
+    assert_no_match(/!/, method.hidden_method.to_s)
+    assert_match(/exclamation_mark_substituted_character_33/, method.hidden_method.to_s)
   end
 
   def test_should_provide_hidden_version_of_method_name_substituting_equals_sign
     method = ClassMethod.new(nil, :equals_sign=)
-    assert_no_match(/\=/, method.hidden_method)
-    assert_match(/equals_sign_substituted_character_61/, method.hidden_method)
+    assert_no_match(/\=/, method.hidden_method.to_s)
+    assert_match(/equals_sign_substituted_character_61/, method.hidden_method.to_s)
   end
 
   def test_should_provide_hidden_version_of_method_name_substituting_brackets
     method = ClassMethod.new(nil, :[])
-    assert_no_match(/\[\]/, method.hidden_method)
-    assert_match(/substituted_character_91__substituted_character_93/, method.hidden_method)
+    assert_no_match(/\[\]/, method.hidden_method.to_s)
+    assert_match(/substituted_character_91__substituted_character_93/, method.hidden_method.to_s)
   end
   
   def test_should_provide_hidden_version_of_method_name_substituting_plus_sign
     method = ClassMethod.new(nil, :+)
-    assert_no_match(/\+/, method.hidden_method)
-    assert_match(/substituted_character_43/, method.hidden_method)
+    assert_no_match(/\+/, method.hidden_method.to_s)
+    assert_match(/substituted_character_43/, method.hidden_method.to_s)
   end
   
   def test_should_hide_original_method
@@ -95,7 +95,7 @@ class ClassMethodTest < Test::Unit::TestCase
     result = klass.method_x(:param1, :param2)
     
     assert_equal :result, result
-    assert mocha.verified?
+    assert mocha.__verified__?
   end
   
   def test_should_remove_new_method

data/test/unit/expectation_list_test.rb

@@ -20,7 +20,7 @@ class ExpectationListTest < Test::Unit::TestCase
     expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.detect(:my_method, :argument3, :argument4)
+    assert_same expectation1, expectation_list.match(:my_method, :argument1, :argument2)
   end
   
   def test_should_find_most_recent_matching_expectation
@@ -29,29 +29,29 @@ class ExpectationListTest < Test::Unit::TestCase
     expectation2 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.detect(:my_method, :argument1, :argument2)
+    assert_same expectation2, expectation_list.match(:my_method, :argument1, :argument2)
   end
   
-  def test_should_find_most_recent_matching_expectation_but_give_preference_to_those_allowing_invocations
+  def test_should_find_matching_expectation_allowing_invocation
     expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
+    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
+    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
     expectation1.define_instance_method(:invocations_allowed?) { true }
-    expectation2.define_instance_method(:invocations_allowed?) { false }
+    expectation2.define_instance_method(:invocations_allowed?) { true }
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.detect(:my_method)
+    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method, :argument1, :argument2)
   end
   
-  def test_should_find_most_recent_matching_expectation_if_no_matching_expectations_allow_invocations
+  def test_should_find_most_recent_matching_expectation_allowing_invocation
     expectation_list = ExpectationList.new
     expectation1 = Expectation.new(nil, :my_method)
     expectation2 = Expectation.new(nil, :my_method)
-    expectation1.define_instance_method(:invocations_allowed?) { false }
+    expectation1.define_instance_method(:invocations_allowed?) { true }
     expectation2.define_instance_method(:invocations_allowed?) { false }
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.detect(:my_method)
+    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method)
   end
-
+  
 end

data/test/unit/expectation_test.rb

@@ -262,7 +262,7 @@ class ExpectationTest < Test::Unit::TestCase
   def test_should_not_verify_successfully_if_expected_call_was_not_made_at_least_once
     expectation = new_expectation.with(1, 2, 3).at_least_once
     assert !expectation.verified?
-    assert_match(/expected at least once, never invoked/i, expectation.mocha_inspect)
+    assert_match(/expected at least once, not yet invoked/i, expectation.mocha_inspect)
   end
   
   def test_should_verify_successfully_if_expected_call_was_made_expected_number_of_times
@@ -275,7 +275,7 @@ class ExpectationTest < Test::Unit::TestCase
     expectation = new_expectation.times(2)
     1.times {expectation.invoke}
     assert !expectation.verified?
-    assert_match(/expected exactly 2 times, already invoked 1 time/i, expectation.mocha_inspect)
+    assert_match(/expected exactly twice, already invoked once/i, expectation.mocha_inspect)
   end
   
   def test_should_not_verify_successfully_if_expected_call_was_made_too_many_times

data/test/unit/mock_test.rb

@@ -54,7 +54,7 @@ class MockTest < Test::Unit::TestCase
     mock = Mock.new
     OBJECT_METHODS.each { |method| mock.__expects__(method.to_sym).returns(method) }
     OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-    assert mock.verified?
+    assert mock.__verified__?
   end
   
   def test_should_be_able_to_stub_standard_object_methods
@@ -113,30 +113,18 @@ class MockTest < Test::Unit::TestCase
     error = assert_raise(ExpectationError) do
       mock.unexpected_method_called(:my_method, :argument1, :argument2)
     end
+    assert_match(/unexpected invocation/, error.message)
     assert_match(/my_method/, error.message)
     assert_match(/argument1/, error.message)
     assert_match(/argument2/, error.message)
   end
   
-  def test_should_indicate_unexpected_method_called
-    mock = Mock.new
-    class << mock
-      attr_accessor :symbol, :arguments
-      def unexpected_method_called(symbol, *arguments)
-        self.symbol, self.arguments = symbol, arguments
-      end
-    end
-    mock.my_method(:argument1, :argument2)
-    assert_equal :my_method, mock.symbol
-    assert_equal [:argument1, :argument2], mock.arguments
-  end
-  
   def test_should_not_verify_successfully_because_not_all_expectations_have_been_satisfied
     mock = Mock.new
     mock.expects(:method1)
     mock.expects(:method2)
     mock.method1
-    assert !mock.verified?
+    assert !mock.__verified__?
   end
   
   def test_should_increment_assertion_counter_for_every_verified_expectation
@@ -150,7 +138,7 @@ class MockTest < Test::Unit::TestCase
     
     assertion_counter = SimpleCounter.new
     
-    mock.verified?(assertion_counter)
+    mock.__verified__?(assertion_counter)
     
     assert_equal 2, assertion_counter.count
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mocha
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - James Mead
@@ -9,7 +9,7 @@ autorequire: mocha
 bindir: bin
 cert_chain: []
 
-date: 2008-06-24 00:00:00 +01:00
+date: 2008-08-30 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -88,12 +88,15 @@ files:
 - lib/mocha/state_machine.rb
 - lib/mocha/stubbing_error.rb
 - lib/mocha/test_case_adapter.rb
+- lib/mocha/unexpected_invocation.rb
 - lib/mocha/yield_parameters.rb
 - lib/mocha.rb
 - lib/mocha_standalone.rb
 - lib/stubba.rb
 - test/acceptance/acceptance_test_helper.rb
 - test/acceptance/bug_18914_test.rb
+- test/acceptance/bug_21465_test.rb
+- test/acceptance/bug_21563_test.rb
 - test/acceptance/expected_invocation_count_test.rb
 - test/acceptance/failure_messages_test.rb
 - test/acceptance/mocha_example_test.rb
@@ -115,6 +118,7 @@ files:
 - test/acceptance/stub_module_method_test.rb
 - test/acceptance/stub_test.rb
 - test/acceptance/stubba_example_test.rb
+- test/acceptance/stubba_test.rb
 - test/acceptance/stubba_test_result_test.rb
 - test/acceptance/stubbing_error_backtrace_test.rb
 - test/acceptance/stubbing_method_unnecessarily_test.rb