mocha 1.10.1 → 1.12.0

data/test/unit/array_inspect_test.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class ArrayInspectTest < Mocha::TestCase
-  def test_should_use_inspect
-    array = [1, 2]
-    assert_equal array.inspect, array.mocha_inspect
-  end
-
-  def test_should_use_mocha_inspect_on_each_item
-    array = [1, 2, 'chris']
-    assert_equal %([1, 2, "chris"]), array.mocha_inspect
-  end
-end

data/test/unit/backtrace_filter_test.rb

@@ -1,17 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/backtrace_filter'
-
-class BacktraceFilterTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = '/username/workspace/mocha_wibble/lib/'
-    backtrace = [mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
-    filter = BacktraceFilter.new(mocha_lib)
-    assert_equal ['/keep/me'], filter.filtered(backtrace)
-  end
-
-  def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new('/lib/$'), BacktraceFilter::LIB_DIRECTORY
-  end
-end

data/test/unit/cardinality_test.rb

@@ -1,72 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/cardinality'
-require 'mocha/invocation'
-require 'mocha/return_values'
-require 'mocha/yield_parameters'
-
-class CardinalityTest < Mocha::TestCase
-  include Mocha
-
-  def new_invocation
-    Invocation.new(:irrelevant, :irrelevant)
-  end
-
-  def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
-    cardinality = Cardinality.new(2, 3)
-    assert cardinality.invocations_allowed?
-    cardinality << new_invocation
-    assert cardinality.invocations_allowed?
-    cardinality << new_invocation
-    assert cardinality.invocations_allowed?
-    cardinality << new_invocation
-    assert !cardinality.invocations_allowed?
-  end
-
-  def test_should_be_satisfied_if_invocations_so_far_have_reached_required_threshold
-    cardinality = Cardinality.new(2, 3)
-    assert !cardinality.satisfied?
-    cardinality << new_invocation
-    assert !cardinality.satisfied?
-    cardinality << new_invocation
-    assert cardinality.satisfied?
-    cardinality << new_invocation
-    assert cardinality.satisfied?
-  end
-
-  def test_should_describe_cardinality_defined_using_at_least
-    assert_equal 'allowed any number of times', Cardinality.at_least(0).anticipated_times
-    assert_equal 'expected at least once', Cardinality.at_least(1).anticipated_times
-    assert_equal 'expected at least twice', Cardinality.at_least(2).anticipated_times
-    assert_equal 'expected at least 3 times', Cardinality.at_least(3).anticipated_times
-  end
-
-  def test_should_describe_cardinality_defined_using_at_most
-    assert_equal 'expected at most once', Cardinality.at_most(1).anticipated_times
-    assert_equal 'expected at most twice', Cardinality.at_most(2).anticipated_times
-    assert_equal 'expected at most 3 times', Cardinality.at_most(3).anticipated_times
-  end
-
-  def test_should_describe_cardinality_defined_using_exactly
-    assert_equal 'expected never', Cardinality.exactly(0).anticipated_times
-    assert_equal 'expected exactly once', Cardinality.exactly(1).anticipated_times
-    assert_equal 'expected exactly twice', Cardinality.exactly(2).anticipated_times
-    assert_equal 'expected exactly 3 times', Cardinality.exactly(3).anticipated_times
-  end
-
-  def test_should_describe_cardinality_defined_using_times_with_range
-    assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).anticipated_times
-    assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).anticipated_times
-  end
-
-  def test_should_need_verifying
-    assert Cardinality.exactly(2).needs_verifying?
-    assert Cardinality.at_least(3).needs_verifying?
-    assert Cardinality.at_most(2).needs_verifying?
-    assert Cardinality.times(4).needs_verifying?
-    assert Cardinality.times(2..4).needs_verifying?
-  end
-
-  def test_should_not_need_verifying
-    assert_equal false, Cardinality.at_least(0).needs_verifying?
-  end
-end

data/test/unit/central_test.rb

@@ -1,98 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/central'
-require 'mocha/mock'
-
-class CentralTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_start_with_empty_stubba_methods
-    stubba = Central.new
-
-    assert_equal [], stubba.stubba_methods
-  end
-
-  def test_should_stub_method_if_not_already_stubbed
-    method = build_mock
-    method.expects(:stub)
-    stubba = Central.new
-
-    stubba.stub(method)
-
-    assert method.__verified__?
-  end
-
-  def test_should_not_stub_method_if_already_stubbed
-    method = build_mock
-    method.stubs(:matches?).returns(true)
-    method.expects(:stub).times(0)
-    stubba = Central.new
-    stubba.stubba_methods = [method]
-
-    stubba.stub(method)
-
-    assert method.__verified__?
-  end
-
-  def test_should_record_method
-    method = build_mock
-    method.expects(:stub)
-    stubba = Central.new
-
-    stubba.stub(method)
-
-    assert_equal [method], stubba.stubba_methods
-  end
-
-  def test_should_unstub_specified_method
-    stubba = Central.new
-    method1 = build_mock
-    method1.stubs(:matches?).returns(false)
-    method2 = build_mock
-    method2.stubs(:matches?).returns(true)
-    method2.expects(:unstub)
-    stubba.stubba_methods = [method1, method2]
-
-    stubba.unstub(method2)
-
-    assert_equal [method1], stubba.stubba_methods
-    assert method2.__verified__?
-  end
-
-  def test_should_not_unstub_specified_method_if_not_already_stubbed
-    stubba = Central.new
-    method1 = build_mock
-    method1.stubs(:matches?).returns(false)
-    method2 = build_mock
-    method2.expects(:unstub).never
-    stubba.stubba_methods = [method1]
-
-    stubba.unstub(method2)
-
-    assert_equal [method1], stubba.stubba_methods
-    assert method2.__verified__?
-  end
-
-  def test_should_unstub_all_methods
-    stubba = Central.new
-    method1 = build_mock
-    method1.stubs(:matches?).returns(true)
-    method1.expects(:unstub)
-    method2 = build_mock
-    method2.stubs(:matches?).returns(true)
-    method2.expects(:unstub)
-    stubba.stubba_methods = [method1, method2]
-
-    stubba.unstub_all
-
-    assert_equal [], stubba.stubba_methods
-    assert method1.__verified__?
-    assert method2.__verified__?
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end

data/test/unit/change_state_side_effect_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/change_state_side_effect'
-
-class ChangeStateSideEffectTest < Mocha::TestCase
-  include Mocha
-
-  class FakeState
-    attr_reader :active
-    attr_writer :description
-
-    def activate
-      @active = true
-    end
-
-    def mocha_inspect
-      @description
-    end
-  end
-
-  def test_should_activate_the_given_state
-    state = FakeState.new
-    side_effect = ChangeStateSideEffect.new(state)
-
-    side_effect.perform
-
-    assert state.active
-  end
-
-  def test_should_describe_itself_in_terms_of_the_activated_state
-    state = FakeState.new
-    state.description = 'the-new-state'
-    side_effect = ChangeStateSideEffect.new(state)
-
-    assert_equal 'then the-new-state', side_effect.mocha_inspect
-  end
-end

data/test/unit/class_methods_test.rb

@@ -1,69 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/class_methods'
-require 'mocha/object_methods'
-require 'mocha/mockery'
-require 'mocha/names'
-
-class ClassMethodsTest < Mocha::TestCase
-  def setup
-    Mocha::Mockery.setup
-    @klass = Class.new.extend(Mocha::ClassMethods, Mocha::ObjectMethods)
-  end
-
-  def teardown
-    Mocha::Mockery.teardown
-  end
-
-  def test_should_build_any_instance_object
-    any_instance = @klass.any_instance
-    assert_not_nil any_instance
-    assert any_instance.is_a?(Mocha::ClassMethods::AnyInstance)
-  end
-
-  def test_should_return_same_any_instance_object
-    any_instance1 = @klass.any_instance
-    any_instance2 = @klass.any_instance
-    assert_equal any_instance1, any_instance2
-  end
-
-  def test_any_instance_should_build_mocha_referring_to_klass
-    mocha = @klass.any_instance.mocha
-    assert_not_nil mocha
-    assert mocha.is_a?(Mocha::Mock)
-    expected_name = Mocha::ImpersonatingAnyInstanceName.new(@klass).mocha_inspect
-    assert_equal expected_name, mocha.mocha_inspect
-  end
-
-  def test_any_instance_should_not_build_mocha_if_instantiate_is_false
-    assert_nil @klass.any_instance.mocha(false)
-  end
-
-  def test_any_instance_should_reuse_existing_mocha
-    mocha1 = @klass.any_instance.mocha
-    mocha2 = @klass.any_instance.mocha
-    assert_equal mocha1, mocha2
-  end
-
-  def test_any_instance_should_reuse_existing_mocha_even_if_instantiate_is_false
-    mocha1 = @klass.any_instance.mocha
-    mocha2 = @klass.any_instance.mocha(false)
-    assert_equal mocha1, mocha2
-  end
-
-  def test_should_use_stubba_class_method_for_class
-    assert_equal Mocha::InstanceMethod, @klass.stubba_method
-  end
-
-  def test_should_use_stubba_class_method_for_any_instance
-    assert_equal Mocha::AnyInstanceMethod, @klass.any_instance.stubba_method
-  end
-
-  def test_should_stub_self_for_class
-    assert_equal @klass, @klass.stubba_object
-  end
-
-  def test_should_stub_relevant_class_for_any_instance
-    any_instance = @klass.any_instance
-    assert_equal @klass, any_instance.stubba_object
-  end
-end

data/test/unit/configuration_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/configuration'
-
-class ConfigurationTest < Mocha::TestCase
-  def test_allow_temporarily_changes_config_when_given_block
-    Mocha.configure { |c| c.stubbing_method_unnecessarily = :warn }
-    yielded = false
-    Mocha::Configuration.override(:stubbing_method_unnecessarily => :allow) do
-      yielded = true
-      assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
-    end
-    assert yielded
-    assert_equal :warn, Mocha.configuration.stubbing_method_unnecessarily
-  end
-
-  def test_prevent_temporarily_changes_config_when_given_block
-    Mocha.configure { |c| c.stubbing_method_unnecessarily = :allow }
-    yielded = false
-    Mocha::Configuration.override(:stubbing_method_unnecessarily => :prevent) do
-      yielded = true
-      assert_equal :prevent, Mocha.configuration.stubbing_method_unnecessarily
-    end
-    assert yielded
-    assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
-  end
-
-  def test_warn_when_temporarily_changes_config_when_given_block
-    Mocha.configure { |c| c.stubbing_method_unnecessarily = :allow }
-    yielded = false
-    Mocha::Configuration.override(:stubbing_method_unnecessarily => :warn) do
-      yielded = true
-      assert_equal :warn, Mocha.configuration.stubbing_method_unnecessarily
-    end
-    assert yielded
-    assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
-  end
-end

data/test/unit/date_time_inspect_test.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class DateTimeInspectTest < Mocha::TestCase
-  def test_should_use_include_date_in_seconds
-    time = Time.now
-    assert_equal "#{time.inspect} (#{time.to_f} secs)", time.mocha_inspect
-  end
-
-  def test_should_use_to_s_for_date
-    date = Date.new(2006, 1, 1)
-    assert_equal date.to_s, date.mocha_inspect
-  end
-
-  def test_should_use_to_s_for_datetime
-    datetime = DateTime.new(2006, 1, 1) # rubocop:disable Style/DateTime
-    assert_equal datetime.to_s, datetime.mocha_inspect
-  end
-end

data/test/unit/exception_raiser_test.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/invocation'
-require 'mocha/exception_raiser'
-require 'timeout'
-
-class ExceptionRaiserTest < Mocha::TestCase
-  include Mocha
-
-  def new_invocation
-    Invocation.new(:irrelevant, :irrelevant)
-  end
-
-  def test_should_raise_exception_with_specified_class_and_default_message
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class, nil)
-    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
-    assert_equal exception_class.to_s, exception.message
-  end
-
-  def test_should_raise_exception_with_specified_class_and_message
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class, 'message')
-    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
-    assert_equal 'message', exception.message
-  end
-
-  def test_should_raise_exception_instance
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class.new('message'), nil)
-    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
-    assert_equal 'message', exception.message
-  end
-
-  def test_should_raise_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
-    raiser = ExceptionRaiser.new(Interrupt, nil)
-    assert_raises(Interrupt) { raiser.evaluate(new_invocation) }
-  end
-
-  def test_should_raise_subclass_of_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
-    exception_class = Class.new(Interrupt)
-    raiser = ExceptionRaiser.new(exception_class, nil)
-    assert_raises(exception_class) { raiser.evaluate(new_invocation) }
-  end
-end

data/test/unit/expectation_list_test.rb

@@ -1,82 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/expectation_list'
-require 'mocha/expectation'
-require 'mocha/invocation'
-require 'set'
-require 'method_definer'
-
-class ExpectationListTest < Mocha::TestCase
-  include MethodDefiner
-  include Mocha
-
-  def test_should_return_added_expectation
-    expectation_list = ExpectationList.new
-    expectation = Expectation.new(nil, :my_method)
-    assert_same expectation, expectation_list.add(expectation)
-  end
-
-  def test_should_find_matching_expectation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
-  end
-
-  def test_should_remove_all_expectations_matching_method_name
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :method_one).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :method_one).with(:argument3, :argument4)
-    expectation3 = Expectation.new(nil, :method_two)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    expectation_list.add(expectation3)
-    expectation_list.remove_all_matching_method(:method_one)
-    assert_nil expectation_list.match(Invocation.new(:irrelevant, :method_one, :argument1, :argument2))
-    assert_nil expectation_list.match(Invocation.new(:irrelevant, :method_one, :argument3, :argument4))
-    assert_same expectation3, expectation_list.match(Invocation.new(:irrelevant, :method_two))
-  end
-
-  def test_should_find_most_recent_matching_expectation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.match(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
-  end
-
-  def test_should_find_matching_expectation_allowing_invocation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    define_instance_method(expectation1, :invocations_allowed?) { true }
-    define_instance_method(expectation2, :invocations_allowed?) { true }
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
-  end
-
-  def test_should_find_most_recent_matching_expectation_allowing_invocation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
-    define_instance_method(expectation1, :invocations_allowed?) { true }
-    define_instance_method(expectation2, :invocations_allowed?) { false }
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(Invocation.new(:irrelevant, :my_method))
-  end
-
-  def test_should_combine_two_expectation_lists_into_one
-    expectation_list1 = ExpectationList.new
-    expectation_list2 = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
-    expectation_list1.add(expectation1)
-    expectation_list2.add(expectation2)
-    expectation_list = expectation_list1 + expectation_list2
-    assert_equal [expectation1, expectation2], expectation_list.to_a
-  end
-end