mocha 0.5.6 → 0.9.0

data/lib/mocha/stubbing_error.rb

@@ -0,0 +1,16 @@
+require 'mocha/backtrace_filter'
+
+module Mocha # :nodoc:
+  
+  # Exception raised when an action prevented by Configuration#prevent is attempted.
+  class StubbingError < StandardError
+
+    def initialize(message = nil, backtrace = []) # :nodoc:
+      super(message)
+      filter = BacktraceFilter.new
+      set_backtrace(filter.filtered(backtrace))
+    end
+
+  end
+  
+end

data/lib/mocha/test_case_adapter.rb

@@ -3,43 +3,97 @@ require 'mocha/expectation_error'
 module Mocha
   
   module TestCaseAdapter
+    
+    class AssertionCounter
+      
+      def initialize(test_result)
+        @test_result = test_result
+      end
+      
+      def increment
+        @test_result.add_assertion
+      end
+      
+    end
 
     def self.included(base)
-      base.class_eval do
+      if RUBY_VERSION < '1.8.6'
+        base.class_eval do
 
-        alias_method :run_before_mocha_test_case_adapter, :run
+          alias_method :run_before_mocha_test_case_adapter, :run
 
-        def run(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-          begin
-            mocha_setup
+          def run(result)
+            assertion_counter = AssertionCounter.new(result)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
             begin
-              setup
-              __send__(@method_name)
-              mocha_verify { add_assertion }
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue StandardError, ScriptError
-              add_error($!)
-            ensure
               begin
-                teardown
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
               rescue Test::Unit::AssertionFailedError => e
                 add_failure(e.message, e.backtrace)
               rescue StandardError, ScriptError
                 add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue StandardError, ScriptError
+                  add_error($!)
+                end
               end
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
           end
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
+
         end
+      else
+        base.class_eval do
+
+          alias_method :run_before_mocha_test_case_adapter, :run
+
+          def run(result)
+            assertion_counter = AssertionCounter.new(result)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
+            begin
+              begin
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue Exception
+                raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Exception
+                  raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                  add_error($!)
+                end
+              end
+            ensure
+              mocha_teardown
+            end
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
+          end
                 
+        end
+        
       end
       
     end

data/lib/stubba.rb

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

data/test/acceptance/acceptance_test_helper.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'test_runner'
+require 'mocha/configuration'
+
+module AcceptanceTest
+  
+  class FakeLogger
+  
+    attr_reader :warnings
+    
+    def initialize
+      @warnings = []
+    end
+    
+    def warn(message)
+      @warnings << message
+    end
+  
+  end
+  
+  attr_reader :logger
+
+  include TestRunner
+  
+  def setup_acceptance_test
+    Mocha::Configuration.reset_configuration
+    @logger = FakeLogger.new
+    mockery = Mocha::Mockery.instance
+    @original_logger = mockery.logger
+    mockery.logger = @logger
+  end
+  
+  def teardown_acceptance_test
+    Mocha::Configuration.reset_configuration
+    Mocha::Mockery.instance.logger = @original_logger
+  end
+  
+end

data/test/acceptance/bug_18914_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class Bug18914Test < Test::Unit::TestCase
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  class AlwaysEql
+    
+    def my_method
+      true
+    end
+    
+    def ==(o)
+      true
+    end
+    
+    def eql?(o)
+      true
+    end
+    
+  end
+
+  def test_should_not_allow_stubbing_of_non_mock_instance_disrupted_by_legitimate_overriding_of_eql_method
+    
+    always_eql_1 = AlwaysEql.new
+    always_eql_1.stubs(:my_method).returns(false)
+    
+    always_eql_2 = AlwaysEql.new
+    always_eql_2.stubs(:my_method).returns(false)
+    
+    assert_equal false, always_eql_2.my_method
+  end
+  
+end

data/test/acceptance/{expected_invocation_count_acceptance_test.rb → expected_invocation_count_test.rb}

@@ -1,10 +1,17 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
 require 'mocha'
-require 'test_runner'
 
-class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
+class ExpectedInvocationCountTest < Test::Unit::TestCase
 
-  include TestRunner
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
 
   def test_should_pass_if_method_is_never_expected_and_is_never_called
     test_result = run_test do
@@ -22,8 +29,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       1.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
+    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
   end
   
   def test_should_pass_if_method_is_expected_twice_and_is_called_twice
@@ -42,8 +48,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       1.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 1'], failure_messages
+    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
   end
   
   def test_should_fail_if_method_is_expected_twice_but_is_called_three_times
@@ -53,8 +58,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       3.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2, actual calls: 3'], failure_messages
+    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
   end
   
   def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_twice
@@ -91,8 +95,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       1.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 1'], failure_messages
+    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
   end
 
   def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
@@ -102,8 +105,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       5.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: 2..4, actual calls: 5'], failure_messages
+    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
   end
   
   def test_should_pass_if_method_is_expected_at_least_once_and_is_called_once
@@ -131,8 +133,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       0.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at least 1, actual calls: 0'], failure_messages
+    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
   end
   
   def test_should_pass_if_method_is_expected_at_most_once_and_is_never_called
@@ -160,8 +161,7 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       2.times { mock.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:mock>.method(any_parameters) - expected calls: at most 1, actual calls: 2'], failure_messages
+    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
   end
   
   def test_should_pass_if_method_is_never_expected_and_is_never_called_even_if_everything_is_stubbed
@@ -180,8 +180,17 @@ class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
       1.times { stub.method }
     end
     assert_failed(test_result)
-    failure_messages = test_result.failures.map { |failure| failure.message }
-    assert_equal ['#<Mock:stub>.method(any_parameters) - expected calls: 0, actual calls: 1'], failure_messages
+    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
+  end
+  
+  def test_should_fail_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
   end
   
 end

data/test/acceptance/failure_messages_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+class FailureMessagesTest < Test::Unit::TestCase
+  
+  OBJECT_ADDRESS_PATTERN = '0x[0-9A-Fa-f]{1,12}'
+  
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+  
+  class Foo; end
+  
+  def test_should_display_class_name_when_expectation_was_on_class
+    test_result = run_test do
+      Foo.expects(:bar)
+    end
+    assert_match Regexp.new('FailureMessagesTest::Foo'), test_result.failures[0].message
+  end
+  
+  def test_should_display_class_name_and_address_when_expectation_was_on_instance
+    test_result = run_test do
+      Foo.new.expects(:bar)
+    end
+    assert_match Regexp.new("#<FailureMessagesTest::Foo:#{OBJECT_ADDRESS_PATTERN}>"), test_result.failures[0].message
+  end
+  
+  def test_should_display_class_name_and_any_instance_prefix_when_expectation_was_on_any_instance
+    test_result = run_test do
+      Foo.any_instance.expects(:bar)
+    end
+    assert_match Regexp.new('#<AnyInstance:FailureMessagesTest::Foo>'), test_result.failures[0].message
+  end
+  
+  def test_should_display_mock_name_when_expectation_was_on_named_mock
+    test_result = run_test do
+      foo = mock('foo')
+      foo.expects(:bar)
+    end
+    assert_match Regexp.new('#<Mock:foo>'), test_result.failures[0].message
+  end
+  
+  def test_should_display_mock_address_when_expectation_was_on_unnamed_mock
+    test_result = run_test do
+      foo = mock()
+      foo.expects(:bar)
+    end
+    assert_match Regexp.new("#<Mock:#{OBJECT_ADDRESS_PATTERN}>"), test_result.failures[0].message
+  end
+  
+  def test_should_display_string_when_expectation_was_on_string
+    test_result = run_test do
+      'Foo'.expects(:bar)
+    end
+    assert_match Regexp.new("'Foo'"), test_result.failures[0].message
+  end
+  
+end

data/test/acceptance/{mocha_acceptance_test.rb → mocha_example_test.rb}

@@ -1,20 +1,20 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'mocha'
 
-class MochaAcceptanceTest < Test::Unit::TestCase
+class MochaExampleTest < Test::Unit::TestCase
   
   class Rover
-
+    
     def initialize(left_track, right_track, steps_per_metre, steps_per_degree)
       @left_track, @right_track, @steps_per_metre, @steps_per_degree = left_track, right_track, steps_per_metre, steps_per_degree
     end
-
+    
     def forward(metres)
       @left_track.step(metres * @steps_per_metre)
       @right_track.step(metres * @steps_per_metre)
       wait
     end
-
+    
     def backward(metres)
       forward(-metres)
     end
@@ -32,7 +32,7 @@ class MochaAcceptanceTest < Test::Unit::TestCase
     def wait
       while (@left_track.moving? or @right_track.moving?); end
     end
-
+    
   end
   
   def test_should_step_both_tracks_forward_ten_steps

data/test/{integration/mocha_test_result_integration_test.rb → acceptance/mocha_test_result_test.rb}

@@ -1,10 +1,19 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/standalone'
-require 'mocha/test_case_adapter'
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
 require 'execution_point'
 
-class MochaTestResultIntegrationTest < Test::Unit::TestCase
+class MochaTestResultTest < Test::Unit::TestCase
   
+  include AcceptanceTest
+  
+  def setup
+    setup_acceptance_test
+  end
+  
+  def teardown
+    teardown_acceptance_test
+  end
+
   def test_should_include_expectation_verification_in_assertion_count
     test_result = run_test do
       object = mock()
@@ -53,53 +62,23 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
     assert_equal 1, test_result.failure_count
   end
   
-  def test_should_display_backtrace_indicating_line_number_where_expects_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      object = mock()
-      execution_point = ExecutionPoint.current; object.expects(:message)
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
   def test_should_display_backtrace_indicating_line_number_where_unexpected_method_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
     execution_point = nil
-    run_test(test_result) do
+    test_result = run_test do
       object = mock()
       execution_point = ExecutionPoint.current; object.message 
     end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+    assert_equal 1, test_result.failure_count
+    assert_equal execution_point, ExecutionPoint.new(test_result.failures[0].location)
   end
   
   def test_should_display_backtrace_indicating_line_number_where_failing_assertion_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
     execution_point = nil
-    run_test(test_result) do
+    test_result = run_test do
       execution_point = ExecutionPoint.current; flunk
     end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def run_test(test_result = Test::Unit::TestResult.new, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      define_method(:test_me, &block)
-    end
-    test = test_class.new(:test_me)
-    test.run(test_result) {}
-    test_result
+    assert_equal 1, test_result.failure_count
+    assert_equal execution_point, ExecutionPoint.new(test_result.failures[0].location)
   end
   
 end