mocha 0.5.6 → 0.9.0

data/test/unit/expectation_test.rb

@@ -3,12 +3,11 @@ require 'method_definer'
 require 'mocha/expectation'
 require 'mocha/sequence'
 require 'execution_point'
-require 'deprecation_disabler'
+require 'simple_counter'
 
 class ExpectationTest < Test::Unit::TestCase
   
   include Mocha
-  include DeprecationDisabler
   
   def new_expectation
     Expectation.new(nil, :expected_method)
@@ -184,24 +183,6 @@ class ExpectationTest < Test::Unit::TestCase
     assert_nil expectation.invoke
   end
   
-  def test_should_return_evaluated_proc
-    proc = lambda { 99 }
-    expectation = new_expectation.returns(proc)
-    result = nil
-    disable_deprecations { result = expectation.invoke }
-    assert_equal 99, result
-  end
-  
-  def test_should_return_evaluated_proc_without_using_is_a_method
-    proc = lambda { 99 }
-    proc.define_instance_accessor(:called)
-    proc.called = false
-    proc.replace_instance_method(:is_a?) { self.called = true; true}
-    expectation = new_expectation.returns(proc)
-    disable_deprecations { expectation.invoke }
-    assert_equal false, proc.called
-  end
-  
   def test_should_raise_runtime_exception
     expectation = new_expectation.raises
     assert_raise(RuntimeError) { expectation.invoke }
@@ -248,101 +229,74 @@ class ExpectationTest < Test::Unit::TestCase
     assert_equal 2, expectation.invoke
   end
   
-  def test_should_not_raise_error_on_verify_if_expected_call_was_made
+  def test_should_verify_successfully_if_expected_call_was_made
     expectation = new_expectation
     expectation.invoke
-    assert_nothing_raised(ExpectationError) {
-      expectation.verify
-    }
+    assert expectation.verified?
   end
   
-  def test_should_raise_error_on_verify_if_call_expected_once_but_invoked_twice
+  def test_should_not_verify_successfully_if_call_expected_once_but_invoked_twice
     expectation = new_expectation.once
     expectation.invoke
     expectation.invoke
-    assert_raises(ExpectationError) {
-      expectation.verify
-    }
+    assert !expectation.verified?
   end
 
-  def test_should_raise_error_on_verify_if_call_expected_once_but_not_invoked
+  def test_should_not_verify_successfully_if_call_expected_once_but_not_invoked
     expectation = new_expectation.once
-    assert_raises(ExpectationError) {
-      expectation.verify
-    }
+    assert !expectation.verified?
   end
 
-  def test_should_not_raise_error_on_verify_if_call_expected_once_and_invoked_once
+  def test_should_verify_successfully_if_call_expected_once_and_invoked_once
     expectation = new_expectation.once
     expectation.invoke
-    assert_nothing_raised(ExpectationError) {
-      expectation.verify
-    }
+    assert expectation.verified?
   end
 
-  def test_should_not_raise_error_on_verify_if_expected_call_was_made_at_least_once
+  def test_should_verify_successfully_if_expected_call_was_made_at_least_once
     expectation = new_expectation.at_least_once
     3.times {expectation.invoke}
-    assert_nothing_raised(ExpectationError) {
-      expectation.verify
-    }
+    assert expectation.verified?
   end
   
-  def test_should_raise_error_on_verify_if_expected_call_was_not_made_at_least_once
+  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
-    e = assert_raise(ExpectationError) {
-      expectation.verify
-    }
-    assert_match(/expected calls: at least 1, actual calls: 0/i, e.message)
+    assert !expectation.verified?
+    assert_match(/expected at least once, never invoked/i, expectation.mocha_inspect)
   end
   
-  def test_should_not_raise_error_on_verify_if_expected_call_was_made_expected_number_of_times
+  def test_should_verify_successfully_if_expected_call_was_made_expected_number_of_times
     expectation = new_expectation.times(2)
     2.times {expectation.invoke}
-    assert_nothing_raised(ExpectationError) {
-      expectation.verify
-    }
+    assert expectation.verified?
   end
   
-  def test_should_expect_call_not_to_be_made
-    expectation = new_expectation
-    expectation.define_instance_accessor(:how_many_times)
-    expectation.replace_instance_method(:times) { |how_many_times| self.how_many_times = how_many_times }
-    expectation.never
-    assert_equal 0, expectation.how_many_times
-  end
-  
-  def test_should_raise_error_on_verify_if_expected_call_was_made_too_few_times
+  def test_should_not_verify_successfully_if_expected_call_was_made_too_few_times
     expectation = new_expectation.times(2)
     1.times {expectation.invoke}
-    e = assert_raise(ExpectationError) {
-      expectation.verify
-    }
-    assert_match(/expected calls: 2, actual calls: 1/i, e.message)
+    assert !expectation.verified?
+    assert_match(/expected exactly 2 times, already invoked 1 time/i, expectation.mocha_inspect)
   end
   
-  def test_should_raise_error_on_verify_if_expected_call_was_made_too_many_times
+  def test_should_not_verify_successfully_if_expected_call_was_made_too_many_times
     expectation = new_expectation.times(2)
     3.times {expectation.invoke}
-    assert_raise(ExpectationError) {
-      expectation.verify
-    }
+    assert !expectation.verified?
   end
   
-  def test_should_yield_self_to_block
+  def test_should_increment_assertion_counter_for_expectation_because_it_does_need_verifyng
     expectation = new_expectation
     expectation.invoke
-    yielded_expectation = nil
-    expectation.verify { |x| yielded_expectation = x }
-    assert_equal expectation, yielded_expectation
+    assertion_counter = SimpleCounter.new
+    expectation.verified?(assertion_counter)
+    assert_equal 1, assertion_counter.count
   end
   
-  def test_should_yield_to_block_before_raising_exception
-    yielded = false
-    assert_raise(ExpectationError) {
-      new_expectation.verify { |x| yielded = true }
-    }
-    assert yielded
+  def test_should_not_increment_assertion_counter_for_stub_because_it_does_not_need_verifying
+    stub = Expectation.new(nil, :expected_method).at_least(0)
+    assertion_counter = SimpleCounter.new
+    stub.verified?(assertion_counter)
+    assert_equal 0, assertion_counter.count
   end
   
   def test_should_store_backtrace_from_point_where_expectation_was_created
@@ -350,21 +304,6 @@ class ExpectationTest < Test::Unit::TestCase
     assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
   end
   
-  def test_should_set_backtrace_on_assertion_failed_error_to_point_where_expectation_was_created
-    execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
-    error = assert_raise(ExpectationError) {  
-      expectation.verify
-    }
-    assert_equal execution_point, ExecutionPoint.new(error.backtrace)
-  end
-  
-  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 }
-    assert exception.message.include?(expectation.method_signature)
-  end
-  
   class FakeMock
     
     def initialize(name)
@@ -381,9 +320,9 @@ class ExpectationTest < Test::Unit::TestCase
     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(1, 2, {'a' => true, :b => false}, [1, 2, 3]); in sequence 'one'; in sequence 'two'", e.message
+    expectation = Expectation.new(mock, :expected_method).with(1, 2, {'a' => true}, {:b => false}, [1, 2, 3]).in_sequence(sequence_one, sequence_two)
+    assert !expectation.verified?
+    assert_match "mock.expected_method(1, 2, {'a' => true}, {:b => false}, [1, 2, 3]); in sequence 'one'; in sequence 'two'", expectation.mocha_inspect
   end
   
   class FakeConstraint
@@ -479,5 +418,42 @@ class ExpectationTest < Test::Unit::TestCase
     assert_equal [expectation], sequence_one.expectations
     assert_equal [expectation], sequence_two.expectations
   end
+  
+  class FakeState
+    
+    def initialize
+      @active = false
+    end
+    
+    def activate
+      @active = true
+    end
+    
+    def active?
+      @active
+    end
+    
+  end
+  
+  def test_should_change_state_when_expectation_is_invoked
+    state = FakeState.new
+    expectation = Expectation.new(nil, :method_one)
+
+    expectation.then(state)
+
+    expectation.invoke
+    assert state.active?
+  end
+  
+  def test_should_match_when_state_is_active
+    state = FakeState.new
+    expectation = Expectation.new(nil, :method_one)
 
+    expectation.when(state)
+    assert !expectation.match?(:method_one)
+    
+    state.activate
+    assert expectation.match?(:method_one)
+  end
+  
 end

data/test/unit/in_state_ordering_constraint_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/in_state_ordering_constraint'
+
+class InStateOrderingConstraintTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  class FakeStatePredicate
+    
+    attr_writer :active, :description
+    
+    def active?
+      @active
+    end
+    
+    def mocha_inspect
+      @description
+    end
+    
+  end
+  
+  def test_should_allow_invocation_when_state_is_active
+    state_predicate = FakeStatePredicate.new
+    ordering_constraint = InStateOrderingConstraint.new(state_predicate)
+    
+    state_predicate.active = true
+    assert ordering_constraint.allows_invocation_now?
+    
+    state_predicate.active = false
+    assert !ordering_constraint.allows_invocation_now?
+  end
+  
+  def test_should_describe_itself_in_terms_of_the_state_predicates_description
+    state_predicate = FakeStatePredicate.new
+    ordering_constraint = InStateOrderingConstraint.new(state_predicate)
+    
+    state_predicate.description = 'the-state-predicate'
+    
+    assert_equal 'when the-state-predicate', ordering_constraint.mocha_inspect
+  end
+  
+end

data/test/unit/mock_test.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'mocha/mock'
 require 'mocha/expectation_error'
 require 'set'
+require 'simple_counter'
 
 class MockTest < Test::Unit::TestCase
   
@@ -33,26 +34,6 @@ class MockTest < Test::Unit::TestCase
     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,12}>$"), mock.mocha_inspect
-  end
-  
-  def test_should_display_name_for_mocha_inspect_if_mock_has_name
-    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,12}>$"), mock.inspect
-  end
-  
-  def test_should_display_name_for_inspect_if_mock_has_name
-    mock = Mock.new('named_mock')
-    assert_equal "#<Mock:named_mock>", mock.inspect
-  end
-
   def test_should_be_able_to_extend_mock_object_with_module
     mock = Mock.new
     assert_nothing_raised(ExpectationError) { mock.extend(Module.new) }
@@ -73,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_nothing_raised(ExpectationError) { mock.verify }
+    assert mock.verified?
   end
   
   def test_should_be_able_to_stub_standard_object_methods
@@ -150,30 +131,28 @@ class MockTest < Test::Unit::TestCase
     assert_equal [:argument1, :argument2], mock.arguments
   end
   
-  def test_should_verify_that_all_expectations_have_been_fulfilled
+  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_raise(ExpectationError) do
-      mock.verify
-    end
-  end
-  
-  def test_should_report_possible_expectations
-    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:\n#{mock.mocha_inspect}.expected_method(1)", exception.message
+    assert !mock.verified?
   end
   
-  def test_should_pass_block_through_to_expectations_verify_method
+  def test_should_increment_assertion_counter_for_every_verified_expectation
     mock = Mock.new
-    expected_expectation = mock.expects(:method1)
+    
+    mock.expects(:method1)
     mock.method1
-    expectations = []
-    mock.verify() { |expectation| expectations << expectation }
-    assert_equal [expected_expectation], expectations
+    
+    mock.expects(:method2)
+    mock.method2
+    
+    assertion_counter = SimpleCounter.new
+    
+    mock.verified?(assertion_counter)
+    
+    assert_equal 2, assertion_counter.count
   end
   
   def test_should_yield_supplied_parameters_to_block

data/test/unit/mockery_test.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mockery'
+require 'mocha/state_machine'
+
+class MockeryTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_build_instance_of_mockery
+    mockery = Mockery.instance
+    assert_not_nil mockery
+    assert_kind_of Mockery, mockery
+  end
+  
+  def test_should_cache_instance_of_mockery
+    mockery_1 = Mockery.instance
+    mockery_2 = Mockery.instance
+    assert_same mockery_1, mockery_2
+  end
+  
+  def test_should_expire_mockery_instance_cache
+    mockery_1 = Mockery.instance
+    Mockery.reset_instance
+    mockery_2 = Mockery.instance
+    assert_not_same mockery_1, mockery_2
+  end
+  
+  def test_should_raise_expectation_error_because_not_all_expectations_are_satisfied
+    mockery = Mockery.new
+    mock_1 = mockery.named_mock('mock-1') { expects(:method_1) }
+    mock_2 = mockery.named_mock('mock-2') { expects(:method_2) }
+    1.times { mock_1.method_1 }
+    0.times { mock_2.method_2 }
+    assert_raises(ExpectationError) { mockery.verify }
+  end
+  
+  def test_should_reset_list_of_mocks_on_teardown
+    mockery = Mockery.new
+    mock = mockery.unnamed_mock { expects(:my_method) }
+    mockery.teardown
+    assert_nothing_raised(ExpectationError) { mockery.verify }
+  end
+  
+  def test_should_build_instance_of_stubba_on_instantiation
+    mockery = Mockery.new
+    assert_not_nil mockery.stubba
+    assert_kind_of Central, mockery.stubba
+  end
+  
+  def test_should_build_new_instance_of_stubba_on_teardown
+    mockery = Mockery.new
+    stubba_1 = mockery.stubba
+    mockery.teardown
+    stubba_2 = mockery.stubba
+    assert_not_same stubba_1, stubba_2
+  end
+  
+  def test_should_build_and_store_new_state_machine
+    mockery = Mockery.new
+    mockery.new_state_machine('state-machine-name')
+    assert_equal 1, mockery.state_machines.length
+    assert_kind_of StateMachine, mockery.state_machines[0]
+  end
+  
+  def test_should_reset_list_of_state_machines_on_teardown
+    mockery = Mockery.new
+    mockery.new_state_machine('state-machine-name')
+    mockery.teardown
+    assert_equal 0, mockery.state_machines.length
+  end
+  
+  class FakeMethod
+    def stub; end
+    def unstub; end
+  end
+  
+  def test_should_unstub_all_methods_on_teardown
+    mockery = Mockery.new
+    stubba = mockery.stubba
+    stubba.stub(FakeMethod.new)
+    mockery.teardown
+    assert stubba.stubba_methods.empty?
+  end
+  
+  def test_should_display_object_id_for_mocha_inspect_if_mock_has_no_name
+    mockery = Mockery.new
+    mock = mockery.unnamed_mock
+    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.mocha_inspect
+  end
+  
+  def test_should_display_object_id_for_inspect_if_mock_has_no_name
+    mockery = Mockery.new
+    mock = mockery.unnamed_mock
+    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.inspect
+  end
+  
+  def test_should_display_name_for_mocha_inspect_if_mock_has_string_name
+    mockery = Mockery.new
+    mock = mockery.named_mock('named_mock')
+    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+  end
+  
+  def test_should_display_name_for_mocha_inspect_if_mock_has_symbol_name
+    mockery = Mockery.new
+    mock = mockery.named_mock(:named_mock)
+    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+  end
+  
+  def test_should_display_name_for_inspect_if_mock_has_string_name
+    mockery = Mockery.new
+    mock = mockery.named_mock('named_mock')
+    assert_equal "#<Mock:named_mock>", mock.inspect
+  end
+  
+  def test_should_display_name_for_inspect_if_mock_has_symbol_name
+    mockery = Mockery.new
+    mock = mockery.named_mock(:named_mock)
+    assert_equal "#<Mock:named_mock>", mock.inspect
+  end
+  
+  def test_should_display_impersonated_object_for_mocha_inspect
+    mockery = Mockery.new
+    instance = Object.new
+    mock = mockery.mock_impersonating(instance)
+    assert_equal "#{instance.mocha_inspect}", mock.mocha_inspect
+  end
+  
+  def test_should_display_impersonated_object_for_inspect
+    mockery = Mockery.new
+    instance = Object.new
+    mock = mockery.mock_impersonating(instance)
+    assert_equal "#{instance.mocha_inspect}", mock.inspect
+  end
+  
+  class FakeClass; end
+  
+  def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_mocha_inspect
+    mockery = Mockery.new
+    mock = mockery.mock_impersonating_any_instance_of(FakeClass)
+    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.mocha_inspect
+  end
+  
+  def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_inspect
+    mockery = Mockery.new
+    mock = mockery.mock_impersonating_any_instance_of(FakeClass)
+    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.inspect
+  end
+  
+end