mocha 1.6.0 → 1.10.1

data/lib/mocha/mini_test.rb

@@ -1,5 +0,0 @@
-require 'mocha/deprecation'
-
-Mocha::Deprecation.warning("`require 'mocha/mini_test'` has been deprecated. Please use `require 'mocha/minitest' instead.")
-
-require 'mocha/minitest'

data/lib/mocha/module_method.rb

@@ -1,8 +0,0 @@
-require 'mocha/class_method'
-
-module Mocha
-
-  class ModuleMethod < ClassMethod
-  end
-
-end

data/lib/mocha/module_methods.rb

@@ -1,14 +0,0 @@
-require 'mocha/module_method'
-
-module Mocha
-
-  # @private
-  module ModuleMethods
-
-    def stubba_method
-      Mocha::ModuleMethod
-    end
-
-  end
-
-end

data/lib/mocha/parameter_matchers/object.rb

@@ -1,17 +0,0 @@
-require 'mocha/parameter_matchers/equals'
-
-module Mocha
-
-  module ObjectMethods
-    # @private
-    def to_matcher
-      Mocha::ParameterMatchers::Equals.new(self)
-    end
-  end
-
-end
-
-# @private
-class Object
-  include Mocha::ObjectMethods
-end

data/lib/mocha/standalone.rb

@@ -1,4 +0,0 @@
-require 'mocha/api'
-require 'mocha/deprecation'
-
-Mocha::Deprecation.warning("`require 'mocha/standalone'` has been deprecated. Please use `require 'mocha/api' instead.")

data/lib/mocha/unexpected_invocation.rb

@@ -1,26 +0,0 @@
-module Mocha
-
-  # Exception raised when an unexpected method is invoked
-  class UnexpectedInvocation
-
-    # @private
-    def initialize(mock, symbol, *arguments)
-      @mock, @symbol, @arguments = mock, symbol, arguments
-    end
-
-    # @private
-    def full_description
-      method_matcher = MethodMatcher.new(@symbol)
-      parameters_matcher = ParametersMatcher.new(@arguments)
-      method_signature = "#{@mock.mocha_inspect}.#{method_matcher.mocha_inspect}#{parameters_matcher.mocha_inspect}"
-      "unexpected invocation: #{method_signature}\n"
-    end
-
-    # @private
-    def short_description
-      "unexpected invocation: #{@symbol}(#{@arguments.join(', ')})"
-    end
-
-  end
-
-end

data/lib/mocha_standalone.rb

@@ -1,4 +0,0 @@
-require 'mocha/api'
-require 'mocha/deprecation'
-
-Mocha::Deprecation.warning("`require 'mocha_standalone'` has been deprecated. Please use `require 'mocha/api' instead.")

data/test/acceptance/mock_with_initializer_block_test.rb

@@ -1,58 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha/setup'
-require 'deprecation_disabler'
-
-class MockWithInitializerBlockTest < Mocha::TestCase
-
-  include AcceptanceTest
-
-  def setup
-    setup_acceptance_test
-  end
-
-  def teardown
-    teardown_acceptance_test
-  end
-
-  def test_should_expect_two_method_invocations_and_receive_both_of_them
-    test_result = run_as_test do
-      DeprecationDisabler.disable_deprecations do
-        mock = mock() do
-          expects(:method_1)
-          expects(:method_2)
-        end
-        mock.method_1
-        mock.method_2
-      end
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_expect_two_method_invocations_but_receive_only_one_of_them
-    test_result = run_as_test do
-      DeprecationDisabler.disable_deprecations do
-        mock = mock() do
-          expects(:method_1)
-          expects(:method_2)
-        end
-        mock.method_1
-      end
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_stub_methods
-    test_result = run_as_test do
-      DeprecationDisabler.disable_deprecations 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
-    end
-    assert_passed(test_result)
-  end
-
-end

data/test/unit/class_method_test.rb

@@ -1,229 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/mock'
-
-require 'mocha/class_method'
-
-class ClassMethodTest < Mocha::TestCase
-
-  include Mocha
-
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-end
-
-  def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = Class.new
-    method = ClassMethod.new(klass, :method_x)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_not_raise_error_hiding_method_in_class_that_implements_method_called_method
-    klass = Class.new { def self.method; end }
-    method = ClassMethod.new(klass, :method)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_define_a_new_method_which_should_call_mocha_method_missing
-    klass = Class.new { def self.method_x; end }
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    result = klass.method_x(:param1, :param2)
-
-    assert_equal :result, result
-    assert mocha.__verified__?
-  end
-
-  def test_should_remove_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.remove_new_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-
-  def test_should_restore_original_method
-    klass = Class.new { def self.method_x; :original_result; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    assert klass.respond_to?(:method_x)
-    assert_equal :original_result, klass.method_x
-  end
-
-  def test_should_restore_original_method_accepting_a_block_parameter
-    klass = Class.new { def self.method_x(&block); block.call if block_given? ; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    block_called = false
-    klass.method_x { block_called = true }
-    assert block_called
-  end
-
-  def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def self.method_x; :new_result; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.restore_original_method
-
-    assert_equal :new_result, klass.method_x
-  end
-
-  def test_should_call_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.hide_original_method
-    method.define_instance_accessor(:hide_called)
-    method.replace_instance_method(:hide_original_method) { self.hide_called = true }
-
-    method.stub
-
-    assert method.hide_called
-  end
-
-  def test_should_call_define_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.define_instance_accessor(:define_called)
-    method.replace_instance_method(:define_new_method) { self.define_called = true }
-
-    method.stub
-
-    assert method.define_called
-  end
-
-  def test_should_call_remove_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    method.replace_instance_method(:reset_mocha) { }
-    method.define_instance_accessor(:remove_called)
-    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
-
-    method.unstub
-
-    assert method.remove_called
-  end
-
-  def test_should_call_restore_original_method
-    klass = Class.new { def self.method_x; end }
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:reset_mocha) { }
-    method.define_instance_accessor(:restore_called)
-    method.replace_instance_method(:restore_original_method) { self.restore_called = true }
-
-    method.unstub
-
-    assert method.restore_called
-  end
-
-  def test_should_call_mocha_unstub
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new { class << self; attr_accessor :unstub_method; end; def self.unstub(method); self.unstub_method = method; end; }
-    mocha.define_instance_method(:any_expectations?) { true }
-    method.replace_instance_method(:mock) { mocha }
-
-    method.unstub
-    assert_equal mocha.unstub_method, :method_x
-  end
-
-  def test_should_call_stubbee_reset_mocha_if_no_expectations_remaining
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new
-    mocha.define_instance_method(:unstub) { |method_name| }
-    mocha.define_instance_method(:any_expectations?) { false }
-    method.replace_instance_method(:mock) { mocha }
-    stubbee = Class.new { attr_accessor :reset_mocha_called; def reset_mocha; self.reset_mocha_called = true; end; }.new
-    method.replace_instance_method(:stubbee) { stubbee }
-
-    method.unstub
-
-    assert stubbee.reset_mocha_called
-  end
-
-  def test_should_return_mock_for_stubbee
-    mocha = Object.new
-    stubbee = Object.new
-    stubbee.define_instance_method(:mocha) { mocha }
-    method = ClassMethod.new(stubbee, :method_name)
-    assert_equal mocha, method.mock
-  end
-
-  def test_should_not_match_if_other_object_has_a_different_class
-    class_method = ClassMethod.new(Object.new, :method)
-    other_object = Object.new
-    assert !class_method.matches?(other_object)
-  end
-
-  def test_should_not_match_if_other_class_method_has_different_stubbee
-    stubbee_1 = Object.new
-    stubbee_2 = Object.new
-    class_method_1 = ClassMethod.new(stubbee_1, :method)
-    class_method_2 = ClassMethod.new(stubbee_2, :method)
-    assert !class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_not_match_if_other_class_method_has_different_method
-    stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method_1)
-    class_method_2 = ClassMethod.new(stubbee, :method_2)
-    assert !class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_so_no_attempt_is_made_to_stub_a_method_twice
-    stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_but_stubbee_equal_method_lies_like_active_record_association_proxy
-    stubbee = Class.new do
-      def equal?(other); false; end
-    end.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end