mocha 0.5.5 → 0.5.6

data/test/test_runner.rb

@@ -20,8 +20,8 @@ module TestRunner
   end
   
   def assert_passed(test_result)
-    flunk "Test failed unexpectedly with message: #{test_result.failures.first.message}" if test_result.failure_count > 0
-    flunk "Test failed unexpectedly with message: #{test_result.errors.first.message}" if test_result.error_count > 0
+    flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
+    flunk "Test failed unexpectedly with message: #{test_result.errors}" if test_result.error_count > 0
   end
 
   def assert_failed(test_result)

data/test/unit/any_instance_method_test.rb

@@ -36,6 +36,7 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     any_instance.define_instance_method(:mocha) { mocha }
     klass.define_instance_method(:any_instance) { any_instance }
     
+    method.hide_original_method
     method.define_new_method
 
     instance = klass.new
@@ -51,6 +52,7 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     hidden_method_x = method.hidden_method.to_sym
     klass.send(:define_method, hidden_method_x, Proc.new { :original_result }) 
     
+    method.remove_new_method
     method.restore_original_method
     
     instance = klass.new

data/test/unit/auto_verify_test.rb

@@ -9,7 +9,6 @@ class AutoVerifyTest < Test::Unit::TestCase
   def setup
     @test_case = Object.new
     class << test_case
-      def self.add_teardown_method(symbol); end
       include Mocha::AutoVerify
     end
   end
@@ -38,7 +37,7 @@ class AutoVerifyTest < Test::Unit::TestCase
   
   def test_should_build_stub_that_stubs_all_methods
     stub = test_case.stub_everything
-    assert stub.stub_everything
+    assert stub.everything_stubbed
   end
   
   def test_should_add_expectations_to_stub_that_stubs_all_methods
@@ -78,7 +77,11 @@ class AutoVerifyTest < Test::Unit::TestCase
     mocks = Array.new(3) do
       mock = Object.new
       mock.define_instance_accessor(:verify_called)
-      mock.define_instance_method(:verify) { self.verify_called = true }
+      class << mock
+        def verify(&block)
+          self.verify_called = true
+        end
+      end
       mock
     end
     test_case.replace_instance_method(:mocks)  { mocks }
@@ -119,4 +122,8 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_equal '#<Mock:named_stub>', stub.mocha_inspect
   end
   
+  def test_should_build_sequence
+    assert_not_nil test_case.sequence('name')
+  end
+  
 end

data/test/unit/central_test.rb

@@ -72,7 +72,7 @@ class CentralTest < Test::Unit::TestCase
     stubba = Central.new
     stubba.stubba_methods = [method_1, method_2]
     
-    assert_equal 2, stubba.unique_mocks.size
+    assert_equal 2, stubba.unique_mocks.length
     assert stubba.unique_mocks.include?(:mock_1)
     assert stubba.unique_mocks.include?(:mock_2)
   end

data/test/unit/class_method_test.rb

@@ -90,6 +90,7 @@ class ClassMethodTest < Test::Unit::TestCase
     mocha.expects(:method_x).with(:param1, :param2).returns(:result)
     method = ClassMethod.new(klass, :method_x)
     
+    method.hide_original_method
     method.define_new_method
     result = klass.method_x(:param1, :param2)
     
@@ -112,6 +113,7 @@ class ClassMethodTest < Test::Unit::TestCase
     hidden_method_x = method.hidden_method.to_sym
     klass.define_instance_method(hidden_method_x) { :original_result }
 
+    method.remove_new_method
     method.restore_original_method
     
     assert_equal :original_result, klass.method_x 
@@ -130,6 +132,7 @@ class ClassMethodTest < Test::Unit::TestCase
   def test_should_call_hide_original_method
     klass = Class.new { def self.method_x; end }
     method = ClassMethod.new(klass, :method_x)
+    method.hide_original_method
     method.define_instance_accessor(:hide_called)
     method.replace_instance_method(:hide_original_method) { self.hide_called = true }
     
@@ -189,6 +192,7 @@ class ClassMethodTest < Test::Unit::TestCase
     mocha = Object.new
     stubbee = Object.new
     stubbee.define_instance_accessor(:mocha) { mocha }
+    stubbee.mocha = nil
     method = ClassMethod.new(stubbee, :method_name)
     assert_equal stubbee.mocha, method.mock
   end

data/test/unit/expectation_error_test.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/expectation_error'
+
+class ExpectationErrorTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_exclude_mocha_locations_from_backtrace
+    mocha_lib = "/username/workspace/mocha_wibble/lib/"
+    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
+    expectation_error = ExpectationError.new(nil, backtrace, mocha_lib)
+    assert_equal ['/keep/me'], expectation_error.backtrace
+  end
+
+  def test_should_determine_path_for_mocha_lib_directory
+    assert_match Regexp.new("/lib/$"), ExpectationError::LIB_DIRECTORY
+  end
+  
+  def test_should_set_error_message
+    expectation_error = ExpectationError.new('message')
+    assert_equal 'message', expectation_error.message
+  end
+
+end

data/test/unit/expectation_list_test.rb

@@ -8,6 +8,12 @@ class ExpectationListTest < Test::Unit::TestCase
   
   include Mocha
   
+  def test_should_return_added_expectation
+    expectation_list = ExpectationList.new
+    expectation = Expectation.new(nil, :my_method)
+    assert_same expectation, expectation_list.add(expectation)
+  end
+
   def test_should_find_matching_expectation
     expectation_list = ExpectationList.new
     expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)

data/test/unit/expectation_test.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'method_definer'
 require 'mocha/expectation'
+require 'mocha/sequence'
 require 'execution_point'
 require 'deprecation_disabler'
 
@@ -357,43 +358,126 @@ class ExpectationTest < Test::Unit::TestCase
     assert_equal execution_point, ExecutionPoint.new(error.backtrace)
   end
   
-  def test_should_display_expectation_message_in_exception_message
+  def test_should_display_expectation_in_exception_message
     options = [:a, :b, {:c => 1, :d => 2}]
     expectation = new_expectation.with(*options)
-    exception = assert_raise(ExpectationError) {
-      expectation.verify
-    }
+    exception = assert_raise(ExpectationError) { expectation.verify }
     assert exception.message.include?(expectation.method_signature)
   end
   
-  def test_should_combine_method_name_and_pretty_parameters
-    arguments = 1, 2, {'a' => true, :b => false}, [1, 2, 3]
-    expectation = new_expectation.with(*arguments)
-    assert_equal "expected_method(#{PrettyParameters.new(arguments).pretty})", expectation.method_signature
-  end
-  
-  def test_should_not_include_parameters_in_message
-    assert_equal "expected_method", new_expectation.method_signature
+  class FakeMock
+    
+    def initialize(name)
+      @name = name
+    end
+
+    def mocha_inspect
+      @name
+    end
+    
   end
   
-  def test_should_raise_error_with_message_indicating_which_method_was_expected_to_be_called_on_which_mock_object
-    mock = Class.new { def mocha_inspect; 'mock'; end }.new
-    expectation = Expectation.new(mock, :expected_method)
+  def test_should_raise_error_with_message_indicating_which_method_was_expected_to_be_called_on_which_mock_object_with_which_parameters_and_in_what_sequences
+    mock = FakeMock.new('mock')
+    sequence_one = Sequence.new('one')
+    sequence_two = Sequence.new('two')
+    expectation = Expectation.new(mock, :expected_method).with(1, 2, {'a' => true, :b => false}, [1, 2, 3]).in_sequence(sequence_one, sequence_two)
     e = assert_raise(ExpectationError) { expectation.verify }
-    assert_match "mock.expected_method", e.message
+    assert_match "mock.expected_method(1, 2, {'a' => true, :b => false}, [1, 2, 3]); in sequence 'one'; in sequence 'two'", e.message
+  end
+  
+  class FakeConstraint
+    
+    def initialize(allows_invocation_now)
+      @allows_invocation_now = allows_invocation_now
+    end
+    
+    def allows_invocation_now?
+      @allows_invocation_now
+    end
+    
+  end
+  
+  def test_should_be_in_correct_order_if_all_ordering_constraints_allow_invocation_now
+    constraint_one = FakeConstraint.new(allows_invocation_now = true)
+    constraint_two = FakeConstraint.new(allows_invocation_now = true)
+    expectation = Expectation.new(nil, :method_one)
+    expectation.add_ordering_constraint(constraint_one)
+    expectation.add_ordering_constraint(constraint_two)
+    assert expectation.in_correct_order?
+  end
+  
+  def test_should_not_be_in_correct_order_if_one_ordering_constraint_does_not_allow_invocation_now
+    constraint_one = FakeConstraint.new(allows_invocation_now = true)
+    constraint_two = FakeConstraint.new(allows_invocation_now = false)
+    expectation = Expectation.new(nil, :method_one)
+    expectation.add_ordering_constraint(constraint_one)
+    expectation.add_ordering_constraint(constraint_two)
+    assert !expectation.in_correct_order?
+  end
+  
+  def test_should_match_if_all_ordering_constraints_allow_invocation_now
+    constraint_one = FakeConstraint.new(allows_invocation_now = true)
+    constraint_two = FakeConstraint.new(allows_invocation_now = true)
+    expectation = Expectation.new(nil, :method_one)
+    expectation.add_ordering_constraint(constraint_one)
+    expectation.add_ordering_constraint(constraint_two)
+    assert expectation.match?(:method_one)
   end
-  
-  def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = "/username/workspace/mocha_wibble/lib/"
-    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
-    expectation = Expectation.new(nil, :expected_method, backtrace)
-    expectation.define_instance_method(:mocha_lib_directory) { mocha_lib }
-    assert_equal ['/keep/me'], expectation.filtered_backtrace
+
+  def test_should_not_match_if_one_ordering_constraints_does_not_allow_invocation_now
+    constraint_one = FakeConstraint.new(allows_invocation_now = true)
+    constraint_two = FakeConstraint.new(allows_invocation_now = false)
+    expectation = Expectation.new(nil, :method_one)
+    expectation.add_ordering_constraint(constraint_one)
+    expectation.add_ordering_constraint(constraint_two)
+    assert !expectation.match?(:method_one)
   end
-  
-  def test_should_determine_path_for_mocha_lib_directory
-    expectation = new_expectation()
-    assert_match Regexp.new("/lib/$"), expectation.mocha_lib_directory
+
+  def test_should_not_be_satisfied_when_required_invocation_has_not_been_made
+    expectation = Expectation.new(nil, :method_one).times(1)
+    assert !expectation.satisfied?
+  end
+
+  def test_should_be_satisfied_when_required_invocation_has_been_made
+    expectation = Expectation.new(nil, :method_one).times(1)
+    expectation.invoke
+    assert expectation.satisfied?
+  end
+
+  def test_should_not_be_satisfied_when_minimum_number_of_invocations_has_not_been_made
+    expectation = Expectation.new(nil, :method_one).at_least(2)
+    expectation.invoke
+    assert !expectation.satisfied?
+  end
+
+  def test_should_be_satisfied_when_minimum_number_of_invocations_has_been_made
+    expectation = Expectation.new(nil, :method_one).at_least(2)
+    2.times { expectation.invoke }
+    assert expectation.satisfied?
+  end
+  
+  class FakeSequence
+    
+    attr_reader :expectations
+    
+    def initialize
+      @expectations = []
+    end
+    
+    def constrain_as_next_in_sequence(expectation)
+      @expectations << expectation
+    end
+    
+  end
+  
+  def test_should_tell_sequences_to_constrain_expectation_as_next_in_sequence
+    sequence_one = FakeSequence.new
+    sequence_two = FakeSequence.new
+    expectation = Expectation.new(nil, :method_one)
+    assert_equal expectation, expectation.in_sequence(sequence_one, sequence_two)
+    assert_equal [expectation], sequence_one.expectations
+    assert_equal [expectation], sequence_two.expectations
   end
 
 end

data/test/unit/method_matcher_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/method_matcher'
+
+class MethodMatcherTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_match_if_actual_method_name_is_same_as_expected_method_name
+    method_matcher = MethodMatcher.new(:method_name)
+    assert method_matcher.match?(:method_name)
+  end
+
+  def test_should_not_match_if_actual_method_name_is_not_same_as_expected_method_name
+    method_matcher = MethodMatcher.new(:method_name)
+    assert !method_matcher.match?(:different_method_name)
+  end
+  
+  def test_should_describe_what_method_is_expected
+    method_matcher = MethodMatcher.new(:method_name)
+    assert_equal "method_name", method_matcher.mocha_inspect
+  end
+
+end

data/test/unit/missing_expectation_test.rb

@@ -1,45 +1,42 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 
 require 'mocha/missing_expectation'
-require 'method_definer'
+require 'mocha/mock'
 
-class MissingExpectationsTest < Test::Unit::TestCase
+class MissingExpectationTest < Test::Unit::TestCase
   
   include Mocha
   
-  def test_should_find_similar_expectations_on_mock
-    mock = Object.new
-    missing_expectation = MissingExpectation.new(mock, :expected_method)
-    method_names = []
-    similar_expectations = [Expectation.new(mock, :expected_method)]
-    mock.define_instance_method(:similar_expectations) { |method_name| method_names << method_name; similar_expectations }
-    assert_equal similar_expectations, missing_expectation.similar_expectations
-    assert_equal [:expected_method], method_names
-  end
-  
   def test_should_report_similar_expectations
-    expectation_1 = Expectation.new(nil, :expected_method).with(1)
-    expectation_2 = Expectation.new(nil, :expected_method).with(2)
-
-    mock = Object.new
-    mock.define_instance_method(:similar_expectations) { [expectation_1, expectation_2] }
-    mock.define_instance_method(:mocha_inspect) { 'mocha_inspect' }
+    mock = Mock.new
+    expectation_1 = mock.expects(:method_one).with(1)
+    expectation_2 = mock.expects(:method_one).with(1, 1)
+    expectation_3 = mock.expects(:method_two).with(2)
 
-    missing_expectation = MissingExpectation.new(mock, :expected_method).with(3)
-    
+    missing_expectation = MissingExpectation.new(mock, :method_one)
     exception = assert_raise(ExpectationError) { missing_expectation.verify }
-    assert_equal "mocha_inspect.expected_method(3) - expected calls: 0, actual calls: 1\nSimilar expectations:\nexpected_method(1)\nexpected_method(2)", exception.message
+    
+    expected_message = [
+      "#{missing_expectation.error_message(0, 1)}",
+      "Similar expectations:",
+      "#{expectation_1.method_signature}",
+      "#{expectation_2.method_signature}"
+    ].join("\n")
+    
+    assert_equal expected_message, exception.message
   end
   
   def test_should_not_report_similar_expectations_if_there_are_none
-    mock = Object.new
-    mock.define_instance_method(:similar_expectations) { [] }
-    mock.define_instance_method(:mocha_inspect) { 'mocha_inspect' }
+    mock = Mock.new
+    mock.expects(:method_two).with(2)
+    mock.expects(:method_two).with(2, 2)
 
-    missing_expectation = MissingExpectation.new(mock, :unexpected_method).with(1)
-    
+    missing_expectation = MissingExpectation.new(mock, :method_one)
     exception = assert_raise(ExpectationError) { missing_expectation.verify }
-    assert_equal "mocha_inspect.unexpected_method(1) - expected calls: 0, actual calls: 1", exception.message
+    
+    expected_message = "#{missing_expectation.error_message(0, 1)}"
+    
+    assert_equal expected_message, exception.message
   end
   
 end

data/test/unit/mock_test.rb

@@ -24,31 +24,32 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_not_stub_everything_by_default
     mock = Mock.new
-    assert_equal false, mock.stub_everything
+    assert_equal false, mock.everything_stubbed
   end
   
   def test_should_stub_everything
-    mock = Mock.new(stub_everything = true)
-    assert_equal true, mock.stub_everything
+    mock = Mock.new
+    mock.stub_everything
+    assert_equal true, mock.everything_stubbed
   end
   
   def test_should_display_object_id_for_mocha_inspect_if_mock_has_no_name
     mock = Mock.new
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,8}>$"), mock.mocha_inspect
+    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.mocha_inspect
   end
   
   def test_should_display_name_for_mocha_inspect_if_mock_has_name
-    mock = Mock.new(false, 'named_mock')
+    mock = Mock.new('named_mock')
     assert_equal "#<Mock:named_mock>", mock.mocha_inspect
   end
 
   def test_should_display_object_id_for_inspect_if_mock_has_no_name
     mock = Mock.new
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,8}>$"), mock.inspect
+    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.inspect
   end
   
   def test_should_display_name_for_inspect_if_mock_has_name
-    mock = Mock.new(false, 'named_mock')
+    mock = Mock.new('named_mock')
     assert_equal "#<Mock:named_mock>", mock.inspect
   end
 
@@ -61,20 +62,24 @@ class MockTest < Test::Unit::TestCase
     mock = Mock.new
     assert_equal true, mock.eql?(mock)
   end
-    
+  
+  if RUBY_VERSION < '1.9'
+    OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ }
+  else
+    OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ || m == :object_id }
+  end
+  
   def test_should_be_able_to_mock_standard_object_methods
     mock = Mock.new
-    object_methods = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ }.sort
-    object_methods.each { |method| mock.__expects__(method.to_sym).returns(method) }
-    object_methods.each { |method| assert_equal method, mock.__send__(method.to_sym) }
+    OBJECT_METHODS.each { |method| mock.__expects__(method.to_sym).returns(method) }
+    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
     assert_nothing_raised(ExpectationError) { mock.verify }
   end
-
+  
   def test_should_be_able_to_stub_standard_object_methods
     mock = Mock.new
-    object_methods = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ }.sort
-    object_methods.each { |method| mock.__stubs__(method.to_sym).returns(method) }
-    object_methods.each { |method| assert_equal method, mock.__send__(method.to_sym) }
+    OBJECT_METHODS.each { |method| mock.__stubs__(method.to_sym).returns(method) }
+    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
   end
   
   def test_should_create_and_add_expectations
@@ -113,7 +118,8 @@ class MockTest < Test::Unit::TestCase
   end
   
   def test_should_not_raise_error_if_stubbing_everything
-    mock = Mock.new(stub_everything = true)
+    mock = Mock.new
+    mock.stub_everything
     result = nil
     assert_nothing_raised(ExpectationError) do
       result = mock.unexpected_method
@@ -158,7 +164,7 @@ class MockTest < Test::Unit::TestCase
     mock = Mock.new
     mock.expects(:expected_method).with(1)
     exception = assert_raise(ExpectationError) { mock.expected_method(2) }
-    assert_equal "#{mock.mocha_inspect}.expected_method(2) - expected calls: 0, actual calls: 1\nSimilar expectations:\nexpected_method(1)", exception.message
+    assert_equal "#{mock.mocha_inspect}.expected_method(2) - expected calls: 0, actual calls: 1\nSimilar expectations:\n#{mock.mocha_inspect}.expected_method(1)", exception.message
   end
   
   def test_should_pass_block_through_to_expectations_verify_method
@@ -248,7 +254,7 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_respond_to_methods_which_the_responder_does_responds_to
     instance = Class.new do
-      define_method(:respond_to?) { true }
+      define_method(:respond_to?) { |symbol| true }
     end.new
     mock = Mock.new
     mock.responds_like(instance)
@@ -257,7 +263,7 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_not_respond_to_methods_which_the_responder_does_not_responds_to
     instance = Class.new do
-      define_method(:respond_to?) { false }
+      define_method(:respond_to?) { |symbol| false }
     end.new
     mock = Mock.new
     mock.responds_like(instance)
@@ -280,7 +286,7 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_not_raise_no_method_error_if_responder_does_respond_to_invoked_method
     instance = Class.new do
-      define_method(:respond_to?) { true }
+      define_method(:respond_to?) { |symbol| true }
     end.new
     mock = Mock.new
     mock.responds_like(instance)
@@ -290,7 +296,7 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_raise_no_method_error_if_responder_does_not_respond_to_invoked_method
     instance = Class.new do
-      define_method(:respond_to?) { false }
+      define_method(:respond_to?) { |symbol| false }
       define_method(:mocha_inspect) { 'mocha_inspect' }
     end.new
     mock = Mock.new
@@ -301,7 +307,7 @@ class MockTest < Test::Unit::TestCase
   
   def test_should_raise_no_method_error_with_message_indicating_that_mock_is_constrained_to_respond_like_responder
     instance = Class.new do
-      define_method(:respond_to?) { false }
+      define_method(:respond_to?) { |symbol| false }
       define_method(:mocha_inspect) { 'mocha_inspect' }
     end.new
     mock = Mock.new
@@ -313,4 +319,5 @@ class MockTest < Test::Unit::TestCase
       assert_match(/which responds like mocha_inspect/, e.message)
     end
   end
+  
 end