mocha 0.2.1 → 0.3.0

data/lib/stubba/instance_method.rb

@@ -14,7 +14,7 @@ module Stubba
     end
   
     def exists?
-      object.respond_to?(method)
+      stubbee.respond_to?(method)
     end
     
   end

data/lib/stubba/object.rb

@@ -24,17 +24,17 @@ class Object
   def expects(symbol) 
     method = stubba_method.new(stubba_object, symbol)
     $stubba.stub(method)
-    mocha.expects(symbol)
+    mocha.expects(symbol, caller)
   end
   
   def stubs(symbol) 
     method = stubba_method.new(stubba_object, symbol)
     $stubba.stub(method)
-    mocha.stubs(symbol)
+    mocha.stubs(symbol, caller)
   end
   
-  def verify(*method_names)
-    mocha.verify(*method_names)
+  def verify
+    mocha.verify
   end
   
 end

data/lib/stubba/setup_and_teardown.rb

@@ -12,8 +12,14 @@ module SetupAndTeardown
   end
   
   def teardown_stubs
-    $stubba.unstub_all if $stubba
-    $stubba = nil
+    if $stubba then
+      begin
+        $stubba.verify_all { add_assertion }
+      ensure
+        $stubba.unstub_all
+        $stubba = nil
+      end
+    end
   end
 
 end

data/test/all_tests.rb

@@ -47,12 +47,16 @@ end
 
 Test::Unit::UI::Console::TestRunner.run(UnitTests)
 
+require 'mocha_test_result_integration_test'
+require 'stubba_test_result_integration_test'
 require 'stubba_integration_test'
 
 class IntegrationTests
   
   def self.suite
     suite = Test::Unit::TestSuite.new('IntegrationTests')
+    suite << MochaTestResultIntegrationTest.suite
+    suite << StubbaTestResultIntegrationTest.suite
     suite << StubbaIntegrationTest.suite
   end
   

data/test/execution_point.rb

@@ -0,0 +1,34 @@
+class ExecutionPoint
+  
+  attr_reader :backtrace
+
+  def self.current
+    new(caller)
+  end
+  
+  def initialize(backtrace)
+    @backtrace = backtrace
+  end
+  
+  def file_name
+    /\A(.*?):\d+/.match(@backtrace.first)[1]
+  end
+  
+  def line_number
+    Integer(/\A.*?:(\d+)/.match(@backtrace.first)[1])
+  end
+
+  def ==(other)
+    return false unless other.is_a?(ExecutionPoint)
+    (file_name == other.file_name) and (line_number == other.line_number)
+  end
+  
+  def to_s
+    "file: #{file_name} line: #{line_number}"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+end

data/test/mocha/auto_verify_test.rb

@@ -14,16 +14,84 @@ class AutoVerifyTest < Test::Unit::TestCase
     end
   end
   
+  def test_should_add_mock_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.mock(expectations)
+    
+    assert_equal :expects, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
+  def test_should_add_stub_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.stub(expectations)
+    
+    assert_equal :stubs, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
+  def test_should_add_greedy_stub_type_expectations
+    test_case.define_instance_accessor(:expectation_type, :expectations)
+    test_case.define_instance_method(:build_mock_with_expectations) do |expectation_type, expectations|
+      self.expectation_type = expectation_type
+      self.expectations = expectations
+    end
+    expectations = { :method1 => :value1, :method2 => :value2 }
+    
+    test_case.stub_everything(expectations)
+    
+    assert_equal :stub_everything, test_case.expectation_type
+    assert_equal expectations, test_case.expectations
+  end
+  
   def test_should_build_mock
-    assert test_case.mock.is_a?(Mocha::Mock)
+    mock = test_case.build_mock_with_expectations
+    assert mock.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectation_to_mock
+    mock = test_case.build_mock_with_expectations(:expects, :expected_method => 'return_value')
+    assert_equal 'return_value', mock.expected_method
+  end
+  
+  def test_should_build_stub
+    stub = test_case.build_mock_with_expectations(:stubs)
+    assert stub.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectation_to_stub
+    stub = test_case.build_mock_with_expectations(:stubs, :stubbed_method => 'return_value')
+    assert_equal 'return_value', stub.stubbed_method
+  end
+  
+  def test_should_build_greedy_stub
+    greedy_stub = test_case.build_mock_with_expectations(:stub_everything)
+    assert greedy_stub.stub_everything
+  end
+  
+  def test_should_add_expectations_to_greedy_stub
+    greedy_mock = test_case.build_mock_with_expectations(:stub_everything, :stubbed_method => 'return_value')
+    assert_equal 'return_value', greedy_mock.stubbed_method
   end
   
   def test_should_build_new_mock_each_time
-    assert_not_equal test_case.mock, test_case.mock
+    assert_not_equal test_case.build_mock_with_expectations, test_case.build_mock_with_expectations
   end
   
   def test_should_store_each_new_mock
-    expected = Array.new(3) { test_case.mock }
+    expected = Array.new(3) { test_case.build_mock_with_expectations }
     assert_equal expected, test_case.mocks
   end
   
@@ -39,6 +107,18 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert mocks.all? { |mock| mock.verify_called }
   end
   
+  def test_should_provide_block_for_adding_assertion
+    mock_class = Class.new do
+      def verify(&block); yield; end
+    end
+    mock = mock_class.new
+    test_case.replace_instance_method(:mocks)  { [mock] }
+    test_case.define_instance_accessor(:add_assertion_called)
+    test_case.define_instance_method(:add_assertion) { self.add_assertion_called = true }
+    test_case.teardown_mocks
+    assert test_case.add_assertion_called
+  end
+  
   def test_should_reset_mocks_on_teardown
     mock = Class.new { define_method(:verify) {} }.new
     test_case.mocks << mock
@@ -46,4 +126,24 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert test_case.mocks.empty?
   end
   
+  def test_should_stub_everything
+    mock = test_case.stub_everything
+    assert_equal true, mock.stub_everything
+  end
+  
+  def test_should_add_mock_to_mocks
+    mock = test_case.mock
+    assert_equal [mock], test_case.mocks
+  end
+  
+  def test_should_add_stub_to_mocks
+    stub = test_case.stub
+    assert_equal [stub], test_case.mocks
+  end
+  
+  def test_should_add_greedy_stub_to_mocks
+    greedy_stub = test_case.stub_everything
+    assert_equal [greedy_stub], test_case.mocks
+  end
+  
 end

data/test/mocha/expectation_test.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'method_definer'
-
 require 'mocha/expectation'
+require 'execution_point'
 
 class ExpectationTest < Test::Unit::TestCase
   
@@ -57,6 +57,39 @@ class ExpectationTest < Test::Unit::TestCase
     assert !expectation.match?(:expected_method, 1, 0, 3)
   end
   
+  def test_should_store_provided_backtrace
+    backtrace = Object.new
+    expectation = Expectation.new(:expected_method, backtrace)
+    assert_equal backtrace, expectation.backtrace
+  end
+  
+  def test_should_default_backtrace_to_caller
+    execution_point = ExecutionPoint.current; expectation = Expectation.new(:expected_method)
+    assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
+  end
+  
+  def test_should_not_yield
+    expectation = Expectation.new(:expected_method)
+    yielded = false
+    expectation.invoke() { yielded = true }
+    assert_equal false, yielded
+  end
+
+  def test_should_yield_no_parameters
+    expectation = Expectation.new(:expected_method).yields
+    yielded_parameters = nil
+    expectation.invoke() { |*parameters| yielded_parameters  = parameters }
+    assert_equal Array.new, yielded_parameters
+  end
+
+  def test_should_yield_with_specified_parameters
+    parameters_for_yield = [1, 2, 3]
+    expectation = Expectation.new(:expected_method).yields(*parameters_for_yield)
+    yielded_parameters = nil
+    expectation.invoke() { |*parameters| yielded_parameters  = parameters }
+    assert_equal parameters_for_yield, yielded_parameters
+  end
+
   def test_should_return_specified_value
     expectation = Expectation.new(:expected_method).returns(99)
     assert_equal 99, expectation.invoke
@@ -153,6 +186,36 @@ class ExpectationTest < Test::Unit::TestCase
     }
   end
   
+  def test_should_yield_self_to_block
+    expectation = Expectation.new(:expected_method)
+    expectation.invoke
+    yielded_expectation = nil
+    expectation.verify { |x| yielded_expectation = x }
+    assert_equal expectation, yielded_expectation
+  end
+  
+  def test_should_yield_to_block_before_raising_exception
+    expectation = Expectation.new(:expected_method)
+    yielded = false
+    assert_raise(Test::Unit::AssertionFailedError) {
+      expectation.verify { |x| yielded = true }
+    }
+    assert yielded
+  end
+  
+  def test_should_store_backtrace_from_point_where_expectation_was_created
+    execution_point = ExecutionPoint.current; expectation = Expectation.new(:expected_method)
+    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(:expected_method)
+    error = assert_raise(Test::Unit::AssertionFailedError) {  
+      expectation.verify
+    }
+    assert_equal execution_point, ExecutionPoint.new(error.backtrace)
+  end
+  
   def test_should_display_expectation_message_in_exception_message
     options = [:a, :b, {:c => 1, :d => 2}]
     expectation = Expectation.new(:expected_method).with(*options)

data/test/mocha/mock_methods_test.rb

@@ -16,6 +16,22 @@ class MockMethodsTest < Test::Unit::TestCase
     assert_equal [expectation1, expectation2].to_set, mock.expectations.to_set
   end
   
+  def test_should_pass_backtrace_into_expectation
+    mock = Object.new
+    mock.extend(MockMethods)
+    backtrace = Object.new
+    expectation = mock.expects(:method1, backtrace)
+    assert_equal backtrace, expectation.backtrace
+  end
+  
+  def test_should_pass_backtrace_into_stub
+    mock = Object.new
+    mock.extend(MockMethods)
+    backtrace = Object.new
+    stub = mock.stubs(:method1, backtrace)
+    assert_equal backtrace, stub.backtrace
+  end
+  
   def test_should_create_and_add_stubs
     mock = Object.new
     mock.extend(MockMethods)
@@ -46,6 +62,17 @@ class MockMethodsTest < Test::Unit::TestCase
     assert_equal :result, result
   end
   
+  def test_should_not_raise_error_if_stubbing_everything
+    mock = Class.new { def initialize; @stub_everything = true; end }.new
+    mock.extend(MockMethods)
+    
+    result = nil
+    assert_nothing_raised(Test::Unit::AssertionFailedError) do
+      result = mock.unexpected_method
+    end
+    assert_nil result
+  end
+  
   def test_should_raise_no_method_error
     mock = Object.new
     mock.extend(MockMethods)
@@ -107,35 +134,44 @@ class MockMethodsTest < Test::Unit::TestCase
     end
   end
   
-  def test_should_only_verify_expectations_matching_method_name
+  def test_should_report_possible_expectations
+    mock = Object.new.extend(MockMethods)
+    mock.expects(:meth).with(1)
+    exception = assert_raise(Test::Unit::AssertionFailedError) { mock.meth(2) }
+    assert_equal "Unexpected message :meth(2)\nSimilar expectations :meth(1)", exception.message
+  end
+  
+  def test_should_pass_block_through_to_expectations_verify_method
     mock = Object.new
     mock.extend(MockMethods)
-    mock.expects(:method1)
-    mock.expects(:method2)
+    expected_expectation = mock.expects(:method1)
     mock.method1
-    assert_nothing_raised(Test::Unit::AssertionFailedError) do
-      mock.verify(:method1)
-    end
-    assert_raise(Test::Unit::AssertionFailedError) do
-      mock.verify(:method2)
-    end
+    expectations = []
+    mock.verify() { |expectation| expectations << expectation }
+    assert_equal [expected_expectation], expectations
+  end
+  
+  def test_should_yield_supplied_parameters_to_block
+    mock = Object.new
+    mock.extend(MockMethods)
+    parameters_for_yield = [1, 2, 3]
+    mock.expects(:method1).yields(*parameters_for_yield)
+    yielded_parameters = nil
+    mock.method1() { |*parameters| yielded_parameters = parameters }
+    assert_equal parameters_for_yield, yielded_parameters
   end
   
-  def test_should_only_verify_expectations_matching_multiple_method_names
+  def test_should_respond_to_expected_method
     mock = Object.new
     mock.extend(MockMethods)
     mock.expects(:method1)
-    mock.expects(:method2)
-    assert_raise(Test::Unit::AssertionFailedError) do
-      mock.verify(:method1, :method2)
-    end
+    assert_equal true, mock.respond_to?(:method1)
   end
   
-  def test_should_report_possible_expectations
-    mock = Object.new.extend(MockMethods)
-    mock.expects(:meth).with(1)
-    exception = assert_raise(Test::Unit::AssertionFailedError) { mock.meth(2) }
-    assert_equal "Unexpected message :meth(2)\nSimilar expectations :meth(1)", exception.message
+  def test_should_not_respond_to_unexpected_method
+    mock = Object.new
+    mock.extend(MockMethods)
+    assert_equal false, mock.respond_to?(:method1)
   end
   
 end

data/test/mocha/mock_test.rb

@@ -17,48 +17,21 @@ class MockTest < Test::Unit::TestCase
    end
   end 
 
-  def test_should_set_multiple_expectations_in_constructor
-   mock = Mock.new(:method1 => 1, :method2 => 2)
-   assert_nothing_raised(Test::Unit::AssertionFailedError) do
-     assert_equal 1, mock.method1
-     assert_equal 2, mock.method2
-   end
-  end 
-
-  def test_should_claim_to_respond_to_any_method
-   mock = Mock.new
-   always_responds = mock.always_responds
-   assert always_responds.respond_to?(:gobble_de_gook)
-  end
-
-  def test_should_raise_exception_if_attempting_to_mock_undefined_method
-   mocked = Class.new
-   mock = Mock.new(mocked.new)
-   assert_raise(Test::Unit::AssertionFailedError) do
-     mock.expects(:method1)
-   end
-  end
-
-  def test_should_not_raise_exception_if_attempting_to_mock_defined_method
-   mocked = Class.new { def method1; end }
-   mock = Mock.new(mocked.new)
-   assert_nothing_raised(Test::Unit::AssertionFailedError) do
-     mock.expects(:method1)
-   end
-  end
-
-  def test_should_not_raise_exception_if_attempting_to_mock_method_when_no_class_specified
-   mock = Mock.new
-   assert_nothing_raised(Test::Unit::AssertionFailedError) do
-     mock.expects(:method1)
-   end
-  end
-
   def test_should_build_and_store_expectations
    mock = Mock.new
    expectation = mock.expects(:method1)
    assert_not_nil expectation
    assert_equal [expectation], mock.expectations
   end
-   
+  
+  def test_should_not_stub_everything_by_default
+    mock = Mock.new
+    assert_equal false, mock.stub_everything
+  end
+  
+  def test_should_stub_everything
+    mock = Mock.new(stub_everything = true)
+    assert_equal true, mock.stub_everything
+  end
+  
 end