mocha 0.5.5 → 0.5.6

data/test/acceptance/mock_with_initializer_block_acceptance_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+require 'test_runner'
+
+class MockWithInitializerBlockAcceptanceTest < Test::Unit::TestCase
+  
+  include TestRunner
+
+  def test_should_expect_two_method_invocations_and_receive_both_of_them
+    test_result = run_test do
+      mock = mock() do
+        expects(:method_1)
+        expects(:method_2)
+      end
+      mock.method_1
+      mock.method_2
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_expect_two_method_invocations_but_receive_only_one_of_them
+    test_result = run_test do
+      mock = mock() do
+        expects(:method_1)
+        expects(:method_2)
+      end
+      mock.method_1
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_stub_methods
+    test_result = run_test do
+      mock = mock() do
+        stubs(:method_1).returns(1)
+        stubs(:method_2).returns(2)
+      end
+      assert_equal 1, mock.method_1
+      assert_equal 2, mock.method_2
+    end
+    assert_passed(test_result)
+  end
+
+end

data/test/acceptance/optional_parameters_acceptance_test.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+require 'test_runner'
+
+class OptionalParameterMatcherAcceptanceTest < Test::Unit::TestCase
+  
+  include TestRunner
+  
+  def test_should_pass_if_all_required_parameters_match_and_no_optional_parameters_are_supplied
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_pass_if_all_required_and_optional_parameters_match_and_some_optional_parameters_are_supplied
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2, 3)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_pass_if_all_required_and_optional_parameters_match_and_all_optional_parameters_are_supplied
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2, 3, 4)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_fail_if_all_required_and_optional_parameters_match_but_too_many_optional_parameters_are_supplied
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2, 3, 4, 5)
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_fail_if_all_required_parameters_match_but_some_optional_parameters_do_not_match
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2, 4)
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_fail_if_all_required_parameters_match_but_no_optional_parameters_match
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(1, 2, optionally(3, 4))
+      mock.method(1, 2, 4, 5)
+    end
+    assert_failed(test_result)
+  end
+
+end

data/test/acceptance/parameter_matcher_acceptance_test.rb

@@ -42,7 +42,7 @@ class ParameterMatcherAcceptanceTest < Test::Unit::TestCase
     assert_failed(test_result)
   end
   
-  def test_should_match_hash_parameter_with_specified_entry
+  def test_should_match_hash_parameter_with_specified_key_value_pair
     test_result = run_test do
       mock = mock()
       mock.expects(:method).with(has_entry(:key_1, 'value_1'))
@@ -51,7 +51,7 @@ class ParameterMatcherAcceptanceTest < Test::Unit::TestCase
     assert_passed(test_result)
   end
 
-  def test_should_not_match_hash_parameter_with_specified_entry
+  def test_should_not_match_hash_parameter_with_specified_key_value_pair
     test_result = run_test do
       mock = mock()
       mock.expects(:method).with(has_entry(:key_1, 'value_2'))
@@ -60,6 +60,42 @@ class ParameterMatcherAcceptanceTest < Test::Unit::TestCase
     assert_failed(test_result)
   end
   
+  def test_should_match_hash_parameter_with_specified_hash_entry
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(has_entry(:key_1 => 'value_1'))
+      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_not_match_hash_parameter_with_specified_hash_entry
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(has_entry(:key_1 => 'value_2'))
+      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
+    end
+    assert_failed(test_result)
+  end
+  
+  def test_should_match_hash_parameter_with_specified_entries
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(has_entries(:key_1 => 'value_1', :key_2 => 'value_2'))
+      mock.method(:key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3')
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_not_match_hash_parameter_with_specified_entries
+    test_result = run_test do
+      mock = mock()
+      mock.expects(:method).with(has_entries(:key_1 => 'value_1', :key_2 => 'value_2'))
+      mock.method(:key_1 => 'value_1', :key_2 => 'value_3')
+    end
+    assert_failed(test_result)
+  end
+  
   def test_should_match_parameter_that_matches_regular_expression
     test_result = run_test do
       mock = mock()

data/test/acceptance/partial_mocks_acceptance_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+require 'test_runner'
+
+class PartialMockAcceptanceTest < Test::Unit::TestCase
+  
+  include TestRunner
+
+  def test_should_pass_if_all_expectations_are_satisfied
+    test_result = run_test do
+      partial_mock_one = "partial_mock_one"
+      partial_mock_two = "partial_mock_two"
+      
+      partial_mock_one.expects(:first)
+      partial_mock_one.expects(:second)
+      partial_mock_two.expects(:third)
+      
+      partial_mock_one.first
+      partial_mock_one.second
+      partial_mock_two.third
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_fail_if_all_expectations_are_not_satisfied
+    test_result = run_test do
+      partial_mock_one = "partial_mock_one"
+      partial_mock_two = "partial_mock_two"
+      
+      partial_mock_one.expects(:first)
+      partial_mock_one.expects(:second)
+      partial_mock_two.expects(:third)
+      
+      partial_mock_one.first
+      partial_mock_two.third
+    end
+    assert_failed(test_result)
+  end
+
+end

data/test/acceptance/sequence_acceptance_test.rb

@@ -0,0 +1,179 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+require 'test_runner'
+
+class SequenceAcceptanceTest < Test::Unit::TestCase
+  
+  include TestRunner
+
+  def test_should_constrain_invocations_to_occur_in_expected_order
+    test_result = run_test do
+      mock = mock()
+      sequence = sequence('one')
+      
+      mock.expects(:first).in_sequence(sequence)
+      mock.expects(:second).in_sequence(sequence)
+      
+      mock.second
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_allow_invocations_in_sequence
+    test_result = run_test do
+      mock = mock()
+      sequence = sequence('one')
+      
+      mock.expects(:first).in_sequence(sequence)
+      mock.expects(:second).in_sequence(sequence)
+      
+      mock.first
+      mock.second
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_constrain_invocations_to_occur_in_expected_order_even_if_expected_on_different_mocks
+    test_result = run_test do
+      mock_one = mock('1')
+      mock_two = mock('2')
+      sequence = sequence('one')
+      
+      mock_one.expects(:first).in_sequence(sequence)
+      mock_two.expects(:second).in_sequence(sequence)
+      
+      mock_two.second
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_allow_invocations_in_sequence_even_if_expected_on_different_mocks
+    test_result = run_test do
+      mock_one = mock('1')
+      mock_two = mock('2')
+      sequence = sequence('one')
+      
+      mock_one.expects(:first).in_sequence(sequence)
+      mock_two.expects(:second).in_sequence(sequence)
+      
+      mock_one.first
+      mock_two.second
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_constrain_invocations_to_occur_in_expected_order_even_if_expected_on_partial_mocks
+    test_result = run_test do
+      partial_mock_one = "1"
+      partial_mock_two = "2"
+      sequence = sequence('one')
+      
+      partial_mock_one.expects(:first).in_sequence(sequence)
+      partial_mock_two.expects(:second).in_sequence(sequence)
+      
+      partial_mock_two.second
+    end
+    assert_failed(test_result)
+  end
+
+  def test_should_allow_invocations_in_sequence_even_if_expected_on_partial_mocks
+    test_result = run_test do
+      partial_mock_one = "1"
+      partial_mock_two = "2"
+      sequence = sequence('one')
+      
+      partial_mock_one.expects(:first).in_sequence(sequence)
+      partial_mock_two.expects(:second).in_sequence(sequence)
+      
+      partial_mock_one.first
+      partial_mock_two.second
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_allow_stub_expectations_to_be_skipped_in_sequence
+    test_result = run_test do
+      mock = mock()
+      sequence = sequence('one')
+      
+      mock.expects(:first).in_sequence(sequence)
+      s = mock.stubs(:second).in_sequence(sequence)
+      mock.expects(:third).in_sequence(sequence)
+      
+      mock.first
+      mock.third
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_regard_sequences_as_independent_of_each_other
+    test_result = run_test do
+      mock = mock()
+      sequence_one = sequence('one')
+      sequence_two = sequence('two')
+      
+      mock.expects(:first).in_sequence(sequence_one)
+      mock.expects(:second).in_sequence(sequence_one)
+      
+      mock.expects(:third).in_sequence(sequence_two)
+      mock.expects(:fourth).in_sequence(sequence_two)
+      
+      mock.first
+      mock.third
+      mock.second
+      mock.fourth
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_include_sequence_in_failure_message
+    test_result = run_test do
+      mock = mock()
+      sequence = sequence('one')
+      
+      mock.expects(:first).in_sequence(sequence)
+      mock.expects(:second).in_sequence(sequence)
+      
+      mock.second
+    end
+    assert_failed(test_result)
+    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
+  end
+
+  def test_should_allow_expectations_to_be_in_more_than_one_sequence
+    test_result = run_test do
+      mock = mock()
+      sequence_one = sequence('one')
+      sequence_two = sequence('two')
+      
+      mock.expects(:first).in_sequence(sequence_one)
+      mock.expects(:second).in_sequence(sequence_two)
+      mock.expects(:three).in_sequence(sequence_one).in_sequence(sequence_two)
+      
+      mock.first
+      mock.three
+    end
+    assert_failed(test_result)
+    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
+    assert_match Regexp.new("in sequence 'two'"), test_result.failures.first.message
+  end
+
+  def test_should_have_shortcut_for_expectations_to_be_in_more_than_one_sequence
+    test_result = run_test do
+      mock = mock()
+      sequence_one = sequence('one')
+      sequence_two = sequence('two')
+      
+      mock.expects(:first).in_sequence(sequence_one)
+      mock.expects(:second).in_sequence(sequence_two)
+      mock.expects(:three).in_sequence(sequence_one, sequence_two)
+      
+      mock.first
+      mock.three
+    end
+    assert_failed(test_result)
+    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
+    assert_match Regexp.new("in sequence 'two'"), test_result.failures.first.message
+  end
+
+end

data/test/integration/mocha_test_result_integration_test.rb

@@ -62,7 +62,7 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
       object = mock()
       execution_point = ExecutionPoint.current; object.expects(:message)
     end
-    assert_equal 1, faults.size
+    assert_equal 1, faults.length
     assert_equal execution_point, ExecutionPoint.new(faults.first.location)
   end
   
@@ -75,7 +75,7 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
       object = mock()
       execution_point = ExecutionPoint.current; object.message 
     end
-    assert_equal 1, faults.size
+    assert_equal 1, faults.length
     assert_equal execution_point, ExecutionPoint.new(faults.first.location)
   end
   
@@ -87,7 +87,7 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
     run_test(test_result) do
       execution_point = ExecutionPoint.current; flunk
     end
-    assert_equal 1, faults.size
+    assert_equal 1, faults.length
     assert_equal execution_point, ExecutionPoint.new(faults.first.location)
   end
   

data/test/integration/stubba_integration_test.rb

@@ -41,7 +41,7 @@ class StubbaIntegrationTest < Test::Unit::TestCase
     end
     
     test.run(Test::Unit::TestResult.new) {}
-    assert_equal 0, DontMessWithMe.mocha.expectations.size
+    assert_equal 0, DontMessWithMe.mocha.expectations.length
   end  
 
   def test_should_stub_instance_method_within_test
@@ -72,7 +72,7 @@ class StubbaIntegrationTest < Test::Unit::TestCase
     end
     
     test.run(Test::Unit::TestResult.new) {}
-    assert_equal 0, instance.mocha.expectations.size
+    assert_equal 0, instance.mocha.expectations.length
   end  
 
   private

data/test/integration/stubba_test_result_integration_test.rb

@@ -55,7 +55,7 @@ class StubbaTestResultIntegrationTest < Test::Unit::TestCase
       object = Class.new { def message; end }.new
       execution_point = ExecutionPoint.current; object.expects(:message)
     end
-    assert_equal 1, faults.size
+    assert_equal 1, faults.length
     assert_equal execution_point, ExecutionPoint.new(faults.first.location)
   end
   
@@ -67,7 +67,7 @@ class StubbaTestResultIntegrationTest < Test::Unit::TestCase
     run_test(test_result) do
       execution_point = ExecutionPoint.current; flunk
     end
-    assert_equal 1, faults.size
+    assert_equal 1, faults.length
     assert_equal execution_point, ExecutionPoint.new(faults.first.location)
   end