bourne 1.0

data/test/unit/have_received_test.rb

@@ -0,0 +1,192 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'test_runner'
+require 'bourne/api'
+require 'bourne/mockery'
+require 'mocha/object'
+require 'matcher_helpers'
+
+module HaveReceivedTestMethods
+
+  include Mocha
+
+  def teardown
+    Mockery.reset_instance
+  end
+
+  def test_passes_if_invocation_exists
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, [])
+    assert_passes do
+      assert_matcher_accepts have_received(method), mock
+    end
+  end
+
+  def test_fails_if_invocation_doesnt_exist
+    method = :a_method
+    mock   = new_mock('a mock')
+    assert_fails do
+      assert_matcher_accepts have_received(method), mock
+    end
+  end
+
+  def test_fails_if_invocation_exists_with_different_arguments
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, [2, 1])
+    assert_fails do
+      assert_matcher_accepts have_received(method).with(1, 2), mock
+    end
+  end
+
+  def test_passes_if_invocation_exists_with_wildcard_arguments
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_matcher_accepts have_received(method).with(is_a(String)), mock
+    end
+  end
+
+  def test_passes_if_invocation_exists_with_exact_arguments
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_matcher_accepts have_received(method).with('hello'), mock
+    end
+  end
+
+  def test_fails_if_invocation_exists_only_on_other_mock
+    method = :a_method
+    mock   = new_mock('a mock')
+    other  = 'another mock'
+    Mockery.instance.invocation(other, method, ['hello'])
+    assert_fails do
+      assert_matcher_accepts have_received(method), mock
+    end
+  end
+
+  def test_passes_if_invocation_exists_for_impersonating_mock
+    method = :a_method
+    object = Object.new
+    mock   = new_mock('a mock')
+
+    class << object
+      attr_accessor :mocha
+    end
+    object.mocha = mock
+
+    Mockery.instance.invocation(mock, method, ['hello'])
+    assert_passes do
+      assert_matcher_accepts have_received(method).with('hello'), object
+    end
+  end
+
+  def test_passes_if_invocation_count_correct
+    method = :a_method
+    mock   = new_mock('a mock')
+    2.times { Mockery.instance.invocation(mock, method, []) }
+    assert_passes do
+      assert_matcher_accepts have_received(method).twice, mock
+    end
+  end
+
+  def test_fails_if_invocation_count_incorrect
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, [])
+    assert_fails do
+      assert_matcher_accepts have_received(method).twice, mock
+    end
+  end
+
+  def test_fails_if_invocation_count_too_low
+    method = :a_method
+    mock   = new_mock('a mock')
+    Mockery.instance.invocation(mock, method, [])
+    assert_fails do
+      assert_matcher_accepts have_received(method).twice, mock
+    end
+  end
+
+  def test_fails_if_invocation_count_too_high
+    method = :a_method
+    mock   = new_mock('a mock')
+    2.times { Mockery.instance.invocation(mock, method, []) }
+    assert_fails do
+      assert_matcher_accepts have_received(method).once, mock
+    end
+  end
+
+  def assert_passes(&block)
+    assert ! fails?(&block)
+  end
+
+  def assert_fails(&block)
+    assert fails?(&block)
+  end
+
+  def fails?
+    begin
+      yield
+      false
+    rescue Test::Unit::AssertionFailedError
+      true
+    end
+  end
+
+end
+
+class PartialHaveReceivedTest < Test::Unit::TestCase
+
+  include TestRunner
+  include Mocha::API
+  include HaveReceivedTestMethods
+
+  class FakeMock
+    def initialize(name)
+      @name = name
+    end
+
+    def inspect
+      @name
+    end
+
+    def mocha
+      self
+    end
+  end
+
+  def new_mock(*args)
+    FakeMock.new(*args)
+  end
+
+end
+
+
+class PureHaveReceivedTest < Test::Unit::TestCase
+
+  include TestRunner
+  include Mocha::API
+  include HaveReceivedTestMethods
+
+  class FakeMock
+    def initialize(name)
+      @name = name
+    end
+
+    def inspect
+      @name
+    end
+
+    def mocha
+      self
+    end
+  end
+
+  def new_mock(*args)
+    Mocha::Mock.new(*args)
+  end
+
+end

data/test/unit/invocation_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'bourne/invocation'
+
+class InvocationTest < Test::Unit::TestCase
+
+  include Mocha
+
+  def test_has_mock_method_name_and_args
+    mock   = 'a mock'
+    method = :call_me
+    args   = [1, 2]
+    invocation = Invocation.new(mock, method, args)
+    assert_equal mock, invocation.mock
+    assert_equal method, invocation.method_name
+    assert_equal args, invocation.arguments
+  end
+end

data/test/unit/mock_test.rb

@@ -0,0 +1,329 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'bourne/mock'
+require 'mocha/expectation_error'
+require 'set'
+require 'simple_counter'
+
+class MockTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_set_single_expectation
+   mock = Mock.new
+   mock.expects(:method1).returns(1)
+   assert_nothing_raised(ExpectationError) do
+     assert_equal 1, mock.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.to_a
+  end
+  
+  def test_should_not_stub_everything_by_default
+    mock = Mock.new
+    assert_equal false, mock.everything_stubbed
+  end
+  
+  def test_should_stub_everything
+    mock = Mock.new
+    mock.stub_everything
+    assert_equal true, mock.everything_stubbed
+  end
+  
+  def test_should_be_able_to_extend_mock_object_with_module
+    mock = Mock.new
+    assert_nothing_raised(ExpectationError) { mock.extend(Module.new) }
+  end
+  
+  def test_should_be_equal
+    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.each { |method| mock.__expects__(method.to_sym).returns(method) }
+    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
+    assert mock.__verified__?
+  end
+  
+  def test_should_be_able_to_stub_standard_object_methods
+    mock = Mock.new
+    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
+    mock = Mock.new
+    expectation1 = mock.expects(:method1)
+    expectation2 = mock.expects(:method2)
+    assert_equal [expectation1, expectation2].to_set, mock.expectations.to_set
+  end
+  
+  def test_should_pass_backtrace_into_expectation
+    mock = Mock.new
+    backtrace = Object.new
+    expectation = mock.expects(:method1, backtrace)
+    assert_equal backtrace, expectation.backtrace
+  end
+  
+  def test_should_pass_backtrace_into_stub
+    mock = Mock.new
+    backtrace = Object.new
+    stub = mock.stubs(:method1, backtrace)
+    assert_equal backtrace, stub.backtrace
+  end
+  
+  def test_should_create_and_add_stubs
+    mock = Mock.new
+    stub1 = mock.stubs(:method1)
+    stub2 = mock.stubs(:method2)
+    assert_equal [stub1, stub2].to_set, mock.expectations.to_set
+  end
+  
+  def test_should_invoke_expectation_and_return_result
+    mock = Mock.new
+    mock.expects(:my_method).returns(:result)
+    result = mock.my_method
+    assert_equal :result, result
+  end
+  
+  def test_should_not_raise_error_if_stubbing_everything
+    mock = Mock.new
+    mock.stub_everything
+    result = nil
+    assert_nothing_raised(ExpectationError) do
+      result = mock.unexpected_method
+    end
+    assert_nil result
+  end
+  
+  def test_should_raise_assertion_error_for_unexpected_method_call
+    mock = Mock.new
+    error = assert_raise(ExpectationError) do
+      mock.unexpected_method_called(:my_method, :argument1, :argument2)
+    end
+    assert_match(/unexpected invocation/, error.message)
+    assert_match(/my_method/, error.message)
+    assert_match(/argument1/, error.message)
+    assert_match(/argument2/, error.message)
+  end
+  
+  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 !mock.__verified__?
+  end
+  
+  def test_should_increment_assertion_counter_for_every_verified_expectation
+    mock = Mock.new
+    
+    mock.expects(:method1)
+    mock.method1
+    
+    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
+    mock = Mock.new
+    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_set_up_multiple_expectations_with_return_values
+    mock = Mock.new
+    mock.expects(:method1 => :result1, :method2 => :result2)
+    assert_equal :result1, mock.method1
+    assert_equal :result2, mock.method2
+  end
+  
+  def test_should_set_up_multiple_stubs_with_return_values
+    mock = Mock.new
+    mock.stubs(:method1 => :result1, :method2 => :result2)
+    assert_equal :result1, mock.method1
+    assert_equal :result2, mock.method2
+  end
+  
+  def test_should_keep_returning_specified_value_for_stubs
+    mock = Mock.new
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+    assert_equal 1, mock.method1
+  end
+  
+  def test_should_keep_returning_specified_value_for_expects
+    mock = Mock.new
+    mock.expects(:method1).times(2).returns(1)
+    assert_equal 1, mock.method1
+    assert_equal 1, mock.method1
+  end
+  
+  def test_should_match_most_recent_call_to_expects
+    mock = Mock.new
+    mock.expects(:method1).returns(0)
+    mock.expects(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
+  def test_should_match_most_recent_call_to_stubs
+    mock = Mock.new
+    mock.stubs(:method1).returns(0)
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
+  def test_should_match_most_recent_call_to_stubs_or_expects
+    mock = Mock.new
+    mock.stubs(:method1).returns(0)
+    mock.expects(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
+  def test_should_match_most_recent_call_to_expects_or_stubs
+    mock = Mock.new
+    mock.expects(:method1).returns(0)
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+  
+  def test_should_respond_to_expected_method
+    mock = Mock.new
+    mock.expects(:method1)
+    assert_equal true, mock.respond_to?(:method1)
+  end
+  
+  def test_should_not_respond_to_unexpected_method
+    mock = Mock.new
+    assert_equal false, mock.respond_to?(:method1)
+  end
+  
+  def test_should_respond_to_methods_which_the_responder_does_responds_to
+    instance = Class.new do
+      define_method(:respond_to?) { |symbol| true }
+    end.new
+    mock = Mock.new
+    mock.responds_like(instance)
+    assert_equal true, mock.respond_to?(:invoked_method)
+  end
+  
+  def test_should_not_respond_to_methods_which_the_responder_does_not_responds_to
+    instance = Class.new do
+      define_method(:respond_to?) { |symbol| false }
+    end.new
+    mock = Mock.new
+    mock.responds_like(instance)
+    assert_equal false, mock.respond_to?(:invoked_method)
+  end
+  
+  def test_should_return_itself_to_allow_method_chaining
+    mock = Mock.new
+    assert_same mock.responds_like(Object.new), mock
+  end
+  
+  def test_should_not_raise_no_method_error_if_mock_is_not_restricted_to_respond_like_a_responder
+    instance = Class.new do
+      define_method(:respond_to?) { true }
+    end.new
+    mock = Mock.new
+    mock.stubs(:invoked_method)
+    assert_nothing_raised(NoMethodError) { mock.invoked_method }
+  end
+  
+  def test_should_not_raise_no_method_error_if_responder_does_respond_to_invoked_method
+    instance = Class.new do
+      define_method(:respond_to?) { |symbol| true }
+    end.new
+    mock = Mock.new
+    mock.responds_like(instance)
+    mock.stubs(:invoked_method)
+    assert_nothing_raised(NoMethodError) { mock.invoked_method }
+  end
+  
+  def test_should_raise_no_method_error_if_responder_does_not_respond_to_invoked_method
+    instance = Class.new do
+      define_method(:respond_to?) { |symbol| false }
+      define_method(:mocha_inspect) { 'mocha_inspect' }
+    end.new
+    mock = Mock.new
+    mock.responds_like(instance)
+    mock.stubs(:invoked_method)
+    assert_raises(NoMethodError) { mock.invoked_method }
+  end
+  
+  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?) { |symbol| false }
+      define_method(:mocha_inspect) { 'mocha_inspect' }
+    end.new
+    mock = Mock.new
+    mock.responds_like(instance)
+    mock.stubs(:invoked_method)
+    begin
+      mock.invoked_method
+    rescue NoMethodError => e
+      assert_match(/which responds like mocha_inspect/, e.message)
+    end
+  end
+  
+  def test_should_handle_respond_to_with_private_methods_param_without_error
+    mock = Mock.new
+    assert_nothing_raised{ mock.respond_to?(:object_id, false) }
+  end
+  
+  def test_should_respond_to_any_method_if_stubbing_everything
+    mock = Mock.new
+    mock.stub_everything
+    assert mock.respond_to?(:abc)
+    assert mock.respond_to?(:xyz)
+  end
+
+  class FakeExpectation
+    attr_reader :args
+
+    def invoke(args)
+      @args = args
+    end
+
+    def match?(*args)
+      true
+    end
+
+    def invocations_allowed?
+      true
+    end
+  end
+
+  def test_should_record_invocations
+    method = :a_method
+    args   = [1, 2]
+    mock = Mock.new(method)
+    expectation = FakeExpectation.new
+    mock.expectations.add expectation
+    mock.send(method, *args)
+
+    assert_equal args, expectation.args
+  end
+  
+end