mocha 1.10.1 → 1.12.0

data/test/integration/test_unit_test.rb

@@ -1,8 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/test_unit'
-require 'integration/shared_tests'
-
-class TestUnitTest < Mocha::TestCase
-  include SharedTests
-end

data/test/method_definer.rb

@@ -1,16 +0,0 @@
-require 'mocha/singleton_class'
-
-module MethodDefiner
-  def define_instance_method(object, method_symbol, &block)
-    object.singleton_class.send(:define_method, method_symbol, block)
-  end
-
-  def replace_instance_method(object, method_symbol, &block)
-    raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless object.respond_to?(method_symbol)
-    define_instance_method(object, method_symbol, &block)
-  end
-
-  def define_instance_accessor(object, *symbols)
-    symbols.each { |symbol| object.singleton_class.send(:attr_accessor, symbol) }
-  end
-end

data/test/mini_test_result.rb

@@ -1,96 +0,0 @@
-require 'stringio'
-require 'minitest/unit'
-
-class MiniTestResult
-  minitest_version = Gem::Version.new(::MiniTest::Unit::VERSION)
-  if Gem::Requirement.new('<= 4.6.1').satisfied_by?(minitest_version)
-    FAILURE_PATTERN = /(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n/m
-    ERROR_PATTERN   = /(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n/m
-    PATTERN_INDICES = { :method => 2, :testcase => 3 }.freeze
-  else
-    FAILURE_PATTERN = /(Failure)\:\n.([^#]+)\#([^ ]+) \[([^\]]+)\]\:\n(.*)\n/m
-    ERROR_PATTERN   = /(Error)\:\n.([^#]+)\#([^ ]+)\:\n(.+?)\n/m
-    PATTERN_INDICES = { :method => 3, :testcase => 2 }.freeze
-  end
-
-  def self.parse_failure(raw)
-    matches = FAILURE_PATTERN.match(raw)
-    return nil unless matches
-    Failure.new(matches[PATTERN_INDICES[:method]], matches[PATTERN_INDICES[:testcase]], [matches[4]], matches[5])
-  end
-
-  def self.parse_error(raw)
-    matches = ERROR_PATTERN.match(raw)
-    return nil unless matches
-    backtrace = raw.gsub(ERROR_PATTERN, '').split("\n").map(&:strip)
-    Error.new(matches[PATTERN_INDICES[:method]], matches[PATTERN_INDICES[:testcase]], matches[4], backtrace)
-  end
-
-  class Failure
-    attr_reader :method, :test_case, :location, :message
-    def initialize(method, test_case, location, message)
-      @method = method
-      @test_case = test_case
-      @location = location
-      @message = message
-    end
-  end
-
-  class Error
-    class Exception
-      attr_reader :message, :backtrace
-      def initialize(message, location)
-        @message = message
-        @backtrace = location
-      end
-    end
-
-    attr_reader :method, :test_case, :exception
-    def initialize(method, test_case, message, backtrace)
-      @method = method
-      @test_case = test_case
-      @exception = Exception.new(message, backtrace)
-    end
-  end
-
-  def initialize(runner, tests)
-    @runner = runner
-    @tests = tests
-  end
-
-  def failure_count
-    @runner.failures
-  end
-
-  def assertion_count
-    @tests.inject(0) { |total, test| total + test._assertions }
-  end
-
-  def error_count
-    @runner.errors
-  end
-
-  def passed?
-    @tests.all?(&:passed?)
-  end
-
-  def failures
-    @runner.report.map { |puked| MiniTestResult.parse_failure(puked) }.compact
-  end
-
-  def errors
-    @runner.report.map { |puked| MiniTestResult.parse_error(puked) }.compact
-  end
-
-  def failure_messages
-    failures.map(&:message)
-  end
-
-  def failure_message_lines
-    failure_messages.map { |message| message.split("\n") }.flatten
-  end
-
-  def error_messages
-    errors.map { |e| e.exception.message }
-  end
-end

data/test/minitest_result.rb

@@ -1,48 +0,0 @@
-require 'forwardable'
-
-class MinitestResult
-  class Failure
-    extend Forwardable
-    def_delegators :@failure, :message, :backtrace
-
-    def initialize(failure)
-      @failure = failure
-    end
-
-    def location
-      Minitest.filter_backtrace(backtrace)
-    end
-  end
-
-  def initialize(tests)
-    @tests = tests
-  end
-
-  def failures
-    @tests.map(&:failures).flatten.select { |r| r.instance_of?(Minitest::Assertion) }.map { |f| Failure.new(f) }
-  end
-
-  def failure_count
-    failures.length
-  end
-
-  def failure_message_lines
-    failures.map { |f| f.message.split("\n") }.flatten
-  end
-
-  def errors
-    @tests.map(&:failures).flatten.select { |r| r.instance_of?(Minitest::UnexpectedError) }
-  end
-
-  def error_count
-    errors.length
-  end
-
-  def error_messages
-    errors.map { |e| e.message.split("\n") }.flatten
-  end
-
-  def assertion_count
-    @tests.inject(0) { |total, test| total + test.assertions }
-  end
-end

data/test/simple_counter.rb

@@ -1,11 +0,0 @@
-class SimpleCounter
-  attr_reader :count
-
-  def initialize
-    @count = 0
-  end
-
-  def increment
-    @count += 1
-  end
-end

data/test/test_helper.rb

@@ -1,58 +0,0 @@
-unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
-  STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.instance_methods + Object.private_instance_methods
-end
-
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
-
-require 'mocha/detection/mini_test'
-
-begin
-  require 'minitest'
-# rubocop:disable Lint/HandleExceptions
-rescue LoadError
-end
-# rubocop:enable Lint/HandleExceptions
-begin
-  require 'minitest/unit'
-# rubocop:disable Lint/HandleExceptions
-rescue LoadError
-end
-# rubocop:enable Lint/HandleExceptions
-
-module Mocha; end
-
-if (minitest_testcase = Mocha::Detection::MiniTest.testcase) && (ENV['MOCHA_RUN_INTEGRATION_TESTS'] != 'test-unit')
-  begin
-    require 'minitest/autorun'
-  rescue LoadError
-    MiniTest::Unit.autorun
-  end
-  # rubocop:disable Style/ClassAndModuleChildren
-  class Mocha::TestCase < minitest_testcase
-    def assert_nothing_raised(exception = StandardError)
-      yield
-    rescue exception => e
-      flunk "Unexpected exception raised: #{e}"
-    end
-
-    alias_method :assert_not_nil, :refute_nil
-    alias_method :assert_raise, :assert_raises
-    alias_method :assert_not_same, :refute_same
-    alias_method :assert_no_match, :refute_match
-  end
-  # rubocop:enable Style/ClassAndModuleChildren
-else
-  require 'test/unit'
-  # rubocop:disable Style/ClassAndModuleChildren
-  class Mocha::TestCase < Test::Unit::TestCase
-    def test_dummy
-      # Some versions (?) of Test::Unit try to run this base class as a test case
-      # and it fails because it has no test methods, so I'm adding a dummy test.
-    end
-  end
-  # rubocop:enable Style/ClassAndModuleChildren
-end

data/test/test_runner.rb

@@ -1,58 +0,0 @@
-require 'assertions'
-
-require 'mocha/detection/mini_test'
-
-module TestRunner
-  def run_as_test(&block)
-    run_as_tests(:test_me => block)
-  end
-
-  # rubocop:disable Metrics/AbcSize
-  def run_as_tests(methods = {})
-    base_class = Mocha::TestCase
-    test_class = Class.new(base_class) do
-      include Assertions
-
-      methods.each do |(method_name, proc)|
-        define_method(method_name, proc)
-      end
-    end
-
-    tests = methods.keys.select { |m| m.to_s[/^test/] }.map { |m| test_class.new(m) }
-
-    if Mocha::Detection::MiniTest.testcase && (ENV['MOCHA_RUN_INTEGRATION_TESTS'] != 'test-unit')
-      minitest_version = Gem::Version.new(Mocha::Detection::MiniTest.version)
-      if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
-        require File.expand_path('../minitest_result', __FILE__)
-        tests.each(&:run)
-        Minitest::Runnable.runnables.delete(test_class)
-        test_result = MinitestResult.new(tests)
-      elsif Gem::Requirement.new('> 0.0.0', '< 5.0.0').satisfied_by?(minitest_version)
-        require File.expand_path('../mini_test_result', __FILE__)
-        runner = MiniTest::Unit.new
-        tests.each do |test|
-          test.run(runner)
-        end
-        test_result = MiniTestResult.new(runner, tests)
-      end
-    else
-      require File.expand_path('../test_unit_result', __FILE__)
-      test_result = TestUnitResult.build_test_result
-      tests.each do |test|
-        test.run(test_result) {}
-      end
-    end
-
-    test_result
-  end
-  # rubocop:enable Metrics/AbcSize
-
-  def assert_passed(test_result)
-    flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
-    flunk "Test failed unexpectedly with message: #{test_result.errors.map(&:exception)}" if test_result.error_count > 0
-  end
-
-  def assert_failed(test_result)
-    flunk 'Test passed unexpectedly' unless test_result.failure_count + test_result.error_count > 0
-  end
-end

data/test/test_unit_result.rb

@@ -1,22 +0,0 @@
-require 'test/unit/testresult'
-
-class TestUnitResult
-  def self.build_test_result
-    test_result = Test::Unit::TestResult.new
-    class << test_result
-      attr_reader :failures, :errors
-      def failure_messages
-        failures.map(&:message)
-      end
-
-      def failure_message_lines
-        failure_messages.map { |message| message.split("\n") }.flatten
-      end
-
-      def error_messages
-        errors.map(&:message)
-      end
-    end
-    test_result
-  end
-end

data/test/unit/any_instance_method_test.rb

@@ -1,175 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/class_methods'
-require 'mocha/mock'
-require 'mocha/any_instance_method'
-
-class AnyInstanceMethodTest < Mocha::TestCase
-  include MethodDefiner
-  include Mocha
-
-  def class_with_method(method, result = nil)
-    Class.new do
-      extend ClassMethods
-      define_method(method) { result } if method
-    end
-  end
-
-  unless RUBY_V2_PLUS
-    def test_should_hide_original_method
-      klass = class_with_method(:method_x)
-      method = AnyInstanceMethod.new(klass, :method_x)
-
-      method.hide_original_method
-
-      assert_equal false, klass.method_defined?(:method_x)
-    end
-  end
-
-  def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = class_with_method(:irrelevant)
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_define_a_new_method
-    klass = class_with_method(:method_x)
-    method = AnyInstanceMethod.new(klass, :method_x)
-    mocha = build_mock
-    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    any_instance = Object.new
-    define_instance_method(any_instance, :mocha) { mocha }
-    define_instance_method(klass, :any_instance) { any_instance }
-
-    method.hide_original_method
-    method.define_new_method
-
-    instance = klass.new
-    result = instance.method_x(:param1, :param2)
-
-    assert_equal :result, result
-    assert mocha.__verified__?
-  end
-
-  def test_should_include_the_filename_and_line_number_in_exceptions
-    klass = class_with_method(:method_x)
-    method = AnyInstanceMethod.new(klass, :method_x)
-    mocha = build_mock
-    mocha.stubs(:method_x).raises(Exception)
-    any_instance = Object.new
-    define_instance_method(any_instance, :mocha) { mocha }
-    define_instance_method(klass, :any_instance) { any_instance }
-
-    method.hide_original_method
-    method.define_new_method
-
-    expected_filename = 'stubbed_method.rb'
-    expected_line_number = 61
-
-    exception = assert_raises(Exception) { klass.new.method_x }
-    matching_line = exception.backtrace.find do |line|
-      filename, line_number, _context = line.split(':')
-      filename.include?(expected_filename) && line_number.to_i == expected_line_number
-    end
-
-    assert_not_nil matching_line, "Expected to find #{expected_filename}:#{expected_line_number} in the backtrace:\n #{exception.backtrace.join("\n")}"
-  end
-
-  def test_should_restore_original_method
-    klass = class_with_method(:method_x, :original_result)
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    instance = klass.new
-    assert instance.respond_to?(:method_x)
-    assert_equal :original_result, instance.method_x
-  end
-
-  def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = class_with_method(:method_x, :new_result)
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    method.restore_original_method
-
-    instance = klass.new
-    assert_equal :new_result, instance.method_x
-  end
-
-  def test_should_call_remove_new_method
-    klass = class_with_method(:method_x)
-    any_instance = build_mock
-    any_instance_mocha = build_mock
-    any_instance.stubs(:mocha).returns(any_instance_mocha)
-    define_instance_method(klass, :any_instance) { any_instance }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    replace_instance_method(method, :restore_original_method) {}
-    replace_instance_method(method, :reset_mocha) {}
-    define_instance_accessor(method, :remove_called)
-    replace_instance_method(method, :remove_new_method) { self.remove_called = true }
-
-    method.unstub
-
-    assert method.remove_called
-  end
-
-  def test_should_call_restore_original_method
-    klass = class_with_method(:method_x)
-    any_instance = build_mock
-    any_instance_mocha = build_mock
-    any_instance.stubs(:mocha).returns(any_instance_mocha)
-    define_instance_method(klass, :any_instance) { any_instance }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    replace_instance_method(method, :remove_new_method) {}
-    replace_instance_method(method, :reset_mocha) {}
-    define_instance_accessor(method, :restore_called)
-    replace_instance_method(method, :restore_original_method) { self.restore_called = true }
-
-    method.unstub
-
-    assert method.restore_called
-  end
-
-  def test_should_call_mock_unstub
-    klass = class_with_method(:method_x)
-
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    replace_instance_method(method, :remove_new_method) {}
-    replace_instance_method(method, :restore_original_method) {}
-    mocha = Class.new do
-      class << self
-        attr_accessor :unstub_method
-      end
-      def self.unstub(method)
-        self.unstub_method = method
-      end
-    end
-    define_instance_method(mocha, :any_expectations?) { true }
-    replace_instance_method(method, :mock) { mocha }
-
-    method.unstub
-
-    assert_equal mocha.unstub_method, :method_x
-  end
-
-  def test_should_return_any_instance_mocha_for_stubbee
-    mocha = Object.new
-    any_instance = Object.new
-    define_instance_method(any_instance, :mocha) { mocha }
-    stubbee = class_with_method(:method_x)
-    define_instance_method(stubbee, :any_instance) { any_instance }
-    method = AnyInstanceMethod.new(stubbee, :method_name)
-    assert_equal stubbee.any_instance.mocha, method.mock
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end