mocha 0.5.6 → 3.1.0

data/test/unit/mock_test.rb

@@ -1,323 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/mock'
-require 'mocha/expectation_error'
-require 'set'
-
-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_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) }
-  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_nothing_raised(ExpectationError) { mock.verify }
-  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(/my_method/, error.message)
-    assert_match(/argument1/, error.message)
-    assert_match(/argument2/, error.message)
-  end
-  
-  def test_should_indicate_unexpected_method_called
-    mock = Mock.new
-    class << mock
-      attr_accessor :symbol, :arguments
-      def unexpected_method_called(symbol, *arguments)
-        self.symbol, self.arguments = symbol, arguments
-      end
-    end
-    mock.my_method(:argument1, :argument2)
-    assert_equal :my_method, mock.symbol
-    assert_equal [:argument1, :argument2], mock.arguments
-  end
-  
-  def test_should_verify_that_all_expectations_have_been_fulfilled
-    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
-  end
-  
-  def test_should_pass_block_through_to_expectations_verify_method
-    mock = Mock.new
-    expected_expectation = mock.expects(:method1)
-    mock.method1
-    expectations = []
-    mock.verify() { |expectation| expectations << expectation }
-    assert_equal [expected_expectation], expectations
-  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
-  
-end

data/test/unit/multiple_yields_test.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-
-require 'mocha/multiple_yields'
-
-class MultipleYieldsTest < Test::Unit::TestCase
-  
-  include Mocha
-
-  def test_should_provide_parameters_for_multiple_yields_in_single_invocation
-    parameter_group = MultipleYields.new([1, 2, 3], [4, 5])
-    parameter_groups = []
-    parameter_group.each do |parameters|
-      parameter_groups << parameters
-    end
-    assert_equal [[1, 2, 3], [4, 5]], parameter_groups
-  end
-  
-end

data/test/unit/no_yield_test.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-
-require 'mocha/no_yields'
-
-class NoYieldsTest < Test::Unit::TestCase
-  
-  include Mocha
-
-  def test_should_provide_parameters_for_no_yields_in_single_invocation
-    parameter_group = NoYields.new
-    parameter_groups = []
-    parameter_group.each do |parameters|
-      parameter_groups << parameters
-    end
-    assert_equal [], parameter_groups
-  end
-  
-end

data/test/unit/object_inspect_test.rb

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/inspect'
-require 'method_definer'
-
-class ObjectInspectTest < Test::Unit::TestCase
-  
-  def test_should_return_default_string_representation_of_object_not_including_instance_variables
-    object = Object.new
-    class << object
-      attr_accessor :attribute
-    end
-    object.attribute = 'instance_variable'
-    assert_match Regexp.new("^#<Object:0x[0-9A-Fa-f]{1,8}.*>$"), object.mocha_inspect
-    assert_no_match(/instance_variable/, object.mocha_inspect)
-  end
-  
-  def test_should_return_customized_string_representation_of_object
-    object = Object.new
-    class << object
-      define_method(:inspect) { 'custom_inspect' }
-    end
-    assert_equal 'custom_inspect', object.mocha_inspect
-  end
-  
-  def test_should_use_underscored_id_instead_of_object_id_or_id_so_that_they_can_be_stubbed
-    object = Object.new
-    object.define_instance_accessor(:called)
-    object.called = false
-    object.replace_instance_method(:object_id) { self.called = true; 1 }
-    if RUBY_VERSION < '1.9'
-      object.replace_instance_method(:id) { self.called = true; 1 }
-    end
-    object.mocha_inspect
-    assert_equal false, object.called
-  end
-  
-end

data/test/unit/object_test.rb

@@ -1,165 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/mock'
-require 'method_definer'
-
-require 'mocha/object'
-
-class ObjectTest < Test::Unit::TestCase
-  
-  include Mocha
-    
-  def test_should_build_mocha
-    instance = Object.new
-    mocha = instance.mocha
-    assert_not_nil mocha
-    assert mocha.is_a?(Mock)
-  end
-  
-  def test_should_reuse_existing_mocha
-    instance = Object.new
-    mocha_1 = instance.mocha
-    mocha_2 = instance.mocha
-    assert_equal mocha_1, mocha_2
-  end
-  
-  def test_should_reset_mocha
-    instance = Object.new
-    assert_nil instance.reset_mocha
-  end
-  
-  def test_should_stub_instance_method
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::InstanceMethod.new(instance, :method1))
-    instance.expects(:method1)
-    $stubba.verify
-  end 
-  
-  def test_should_build_and_store_expectation
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = instance.expects(:method1)
-    assert_equal [expectation], instance.mocha.expectations.to_a
-  end
-  
-  def test_should_verify_expectations
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    instance.expects(:method1).with(:value1, :value2)
-    assert_raise(ExpectationError) { instance.verify }
-  end
-  
-  def test_should_pass_backtrace_into_expects
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    mocha = Object.new
-    mocha.define_instance_accessor(:expects_parameters)
-    mocha.define_instance_method(:expects) { |*parameters| self.expects_parameters = parameters }
-    backtrace = Object.new
-    instance.define_instance_method(:mocha) { mocha }
-    instance.define_instance_method(:caller) { backtrace }
-    instance.expects(:method1)
-    assert_equal [:method1, backtrace], mocha.expects_parameters
-  end
-      
-  def test_should_pass_backtrace_into_stubs
-    instance = Object.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    mocha = Object.new
-    mocha.define_instance_accessor(:stubs_parameters)
-    mocha.define_instance_method(:stubs) { |*parameters| self.stubs_parameters = parameters }
-    backtrace = Object.new
-    instance.define_instance_method(:mocha) { mocha }
-    instance.define_instance_method(:caller) { backtrace }
-    instance.stubs(:method1)
-    assert_equal [:method1, backtrace], mocha.stubs_parameters
-  end
-      
-  def test_should_build_any_instance_object
-    klass = Class.new
-    any_instance = klass.any_instance
-    assert_not_nil any_instance
-    assert any_instance.is_a?(Class::AnyInstance)
-  end
-  
-  def test_should_return_same_any_instance_object
-    klass = Class.new
-    any_instance_1 = klass.any_instance
-    any_instance_2 = klass.any_instance
-    assert_equal any_instance_1, any_instance_2
-  end
-  
-  def test_should_stub_class_method
-    klass = Class.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::ClassMethod.new(klass, :method1))
-    klass.expects(:method1)
-    $stubba.verify
-  end 
-  
-  def test_should_build_and_store_class_method_expectation
-    klass = Class.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = klass.expects(:method1)
-    assert_equal [expectation], klass.mocha.expectations.to_a
-  end
-  
-  def test_should_stub_module_method
-    mod = Module.new
-    $stubba = Mock.new
-    $stubba.expects(:stub).with(Mocha::ClassMethod.new(mod, :method1))
-    mod.expects(:method1)
-    $stubba.verify
-  end
-  
-  def test_should_build_and_store_module_method_expectation
-    mod = Module.new
-    $stubba = Mock.new
-    $stubba.stubs(:stub)
-    expectation = mod.expects(:method1)
-    assert_equal [expectation], mod.mocha.expectations.to_a
-  end
-  
-  def test_should_use_stubba_instance_method_for_object
-    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
-  end
-    
-  def test_should_use_stubba_class_method_for_module
-    assert_equal Mocha::ClassMethod, Module.new.stubba_method
-  end
-    
-  def test_should_use_stubba_class_method_for_class
-    assert_equal Mocha::ClassMethod, Class.new.stubba_method
-  end
-  
-  def test_should_use_stubba_class_method_for_any_instance
-    assert_equal Mocha::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
-  end
-  
-  def test_should_stub_self_for_object
-    object = Object.new
-    assert_equal object, object.stubba_object
-  end
-      
-  def test_should_stub_self_for_module
-    mod = Module.new
-    assert_equal mod, mod.stubba_object
-  end
-      
-  def test_should_stub_self_for_class
-    klass = Class.new
-    assert_equal klass, klass.stubba_object
-  end
-      
-  def test_should_stub_relevant_class_for_any_instance
-    klass = Class.new
-    any_instance = Class::AnyInstance.new(klass)
-    assert_equal klass, any_instance.stubba_object
-  end
-  
-end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -1,26 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
-
-require 'mocha/parameter_matchers/all_of'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class AllOfTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_if_all_matchers_match
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(true), Stub::Matcher.new(true))
-    assert matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_not_match_if_any_matcher_does_not_match
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
-    assert !matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_describe_matcher
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
-    assert_equal 'all_of(matcher(true), matcher(false), matcher(true))', matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameter_matchers/any_of_test.rb

@@ -1,26 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
-
-require 'mocha/parameter_matchers/any_of'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class AnyOfTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_if_any_matchers_match
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
-    assert matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_not_match_if_no_matchers_match
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(false), Stub::Matcher.new(false))
-    assert !matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_describe_matcher
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
-    assert_equal 'any_of(matcher(false), matcher(true), matcher(false))', matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameter_matchers/anything_test.rb

@@ -1,21 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
-
-require 'mocha/parameter_matchers/anything'
-require 'mocha/inspect'
-
-class AnythingTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_anything
-    matcher = anything
-    assert matcher.matches?([:something])
-    assert matcher.matches?([{'x' => 'y'}])
-  end
-  
-  def test_should_describe_matcher
-    matcher = anything
-    assert_equal "anything", matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
-
-require 'mocha/parameter_matchers/has_entries'
-require 'mocha/inspect'
-
-class HasEntriesTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_hash_including_specified_entries
-    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entries
-    matcher = has_entries(:key_1 => 'value_2', :key_2 => 'value_2', :key_3 => 'value_3')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_describe_matcher
-    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
-    description = matcher.mocha_inspect
-    matches = /has_entries\((.*)\)/.match(description)
-    assert_not_nil matches[0]
-    entries = eval(matches[1])
-    assert_equal 'value_1', entries[:key_1]
-    assert_equal 'value_2', entries[:key_2]
-  end
-  
-end