mocha 1.1.0 → 1.13.0

data/test/acceptance/unstubbing_test.rb

@@ -1,168 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha/setup'
-
-class UnstubbingTest < Mocha::TestCase
-
-  include AcceptanceTest
-
-  def setup
-    setup_acceptance_test
-  end
-
-  def teardown
-    teardown_acceptance_test
-  end
-
-  def test_unstubbing_an_instance_method_should_restore_original_behaviour
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.stubs(:my_instance_method).returns(:new_return_value)
-      object.unstub(:my_instance_method)
-      assert_equal :original_return_value, object.my_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_class_method_should_restore_original_behaviour
-    klass = Class.new do
-      def self.my_class_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      klass.stubs(:my_class_method).returns(:new_return_value)
-      klass.unstub(:my_class_method)
-      assert_equal :original_return_value, klass.my_class_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_module_method_should_restore_original_behaviour
-    mod = Module.new do
-      def self.my_module_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      mod.stubs(:my_module_method).returns(:new_return_value)
-      mod.unstub(:my_module_method)
-      assert_equal :original_return_value, mod.my_module_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_module_method_defined_like_fileutils_in_ruby_2_0_should_restore_original_behaviour
-    mod = Module.new do
-      def my_module_method; :original_return_value; end
-      private :my_module_method
-      extend self
-      class << self
-        public :my_module_method
-      end
-    end
-    test_result = run_as_test do
-      mod.stubs(:my_module_method).returns(:new_return_value)
-      mod.unstub(:my_module_method)
-      assert_equal :original_return_value, mod.my_module_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_an_any_instance_method_should_restore_original_behaviour
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      klass.any_instance.stubs(:my_instance_method).returns(:new_return_value)
-      klass.any_instance.unstub(:my_instance_method)
-      assert_equal :original_return_value, object.my_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_multiple_methods_should_restore_original_behaviour
-    klass = Class.new do
-      def my_first_instance_method; :original_return_value; end
-      def my_second_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.stubs(:my_first_instance_method).returns(:new_return_value)
-      object.stubs(:my_second_instance_method).returns(:new_return_value)
-      object.unstub(:my_first_instance_method, :my_second_instance_method)
-      assert_equal :original_return_value, object.my_first_instance_method
-      assert_equal :original_return_value, object.my_second_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_method_multiple_times_should_restore_original_behaviour
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.stubs(:my_instance_method).returns(:new_return_value)
-      object.unstub(:my_instance_method)
-      object.unstub(:my_instance_method)
-      assert_equal :original_return_value, object.my_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_non_stubbed_method_should_do_nothing
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.unstub(:my_instance_method)
-      assert_equal :original_return_value, object.my_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_method_which_was_stubbed_multiple_times_should_restore_orginal_behaviour
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.stubs(:my_instance_method).with(:first).returns(:first_new_return_value)
-      object.stubs(:my_instance_method).with(:second).returns(:second_new_return_value)
-      object.unstub(:my_instance_method)
-      assert_equal :original_return_value, object.my_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_method_should_not_unstub_other_stubbed_methods
-    klass = Class.new do
-      def my_first_instance_method; :first_return_value; end
-      def my_second_instance_method; :second_return_value; end
-    end
-
-    test_result = run_as_test do
-      object = klass.new
-      object.stubs(:my_first_instance_method).returns(:first_new_return_value)
-      object.stubs(:my_second_instance_method).returns(:second_new_return_value)
-      object.unstub(:my_first_instance_method)
-      assert_equal :first_return_value, object.my_first_instance_method
-      assert_equal :second_new_return_value, object.my_second_instance_method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_unstubbing_a_method_should_remove_all_expectations_for_that_method
-    klass = Class.new do
-      def my_instance_method; :original_return_value; end
-    end
-    test_result = run_as_test do
-      object = klass.new
-      object.expects(:my_instance_method).with(:first)
-      object.expects(:my_instance_method).with(:second)
-      object.unstub(:my_instance_method)
-    end
-    assert_passed(test_result)
-  end
-end

data/test/assertions.rb

@@ -1,6 +0,0 @@
-module Assertions
-  def assert_method_visiblity(object, method_name, visiblity)
-    method_key = RUBY_VERSION < '1.9' ? method_name.to_s : method_name.to_sym
-    assert object.send("#{visiblity}_methods", false).include?(method_key), "#{method_name} is not #{visiblity}"
-  end
-end

data/test/deprecation_disabler.rb

@@ -1,15 +0,0 @@
-require 'mocha/deprecation'
-
-module DeprecationDisabler
-
-  def disable_deprecations
-    original_mode = Mocha::Deprecation.mode
-    Mocha::Deprecation.mode = :disabled
-    begin
-      yield
-    ensure
-      Mocha::Deprecation.mode = original_mode
-    end
-  end
-
-end

data/test/execution_point.rb

@@ -1,36 +0,0 @@
-class ExecutionPoint
-
-  attr_reader :backtrace
-
-  def self.current
-    new(caller)
-  end
-
-  def initialize(backtrace)
-    @backtrace = backtrace
-  end
-
-  def file_name
-    return "unknown" unless @backtrace && @backtrace.first
-    /\A(.*?):\d+/.match(@backtrace.first)[1]
-  end
-
-  def line_number
-    return "unknown" unless @backtrace && @backtrace.first
-    Integer(/\A.*?:(\d+)/.match(@backtrace.first)[1])
-  end
-
-  def ==(other)
-    return false unless other.is_a?(ExecutionPoint)
-    (file_name == other.file_name) and (line_number == other.line_number)
-  end
-
-  def to_s
-    "file: #{file_name}; line: #{line_number}"
-  end
-
-  def inspect
-    to_s
-  end
-
-end

data/test/integration/mini_test_test.rb

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

data/test/integration/shared_tests.rb

@@ -1,174 +0,0 @@
-require 'test_runner'
-require 'execution_point'
-
-module SharedTests
-  include TestRunner
-
-  def test_assertion_satisfied
-    test_result = run_as_test do
-      assert true
-    end
-    assert_passed(test_result)
-  end
-
-  def test_assertion_unsatisfied
-    execution_point = nil
-    test_result = run_as_test do
-      execution_point = ExecutionPoint.current; flunk
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-  end
-
-  def test_mock_object_unexpected_invocation
-    execution_point = nil
-    test_result = run_as_test do
-      mock = mock("not expecting invocation")
-      execution_point = ExecutionPoint.current; mock.unexpected
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal ["unexpected invocation: #<Mock:not expecting invocation>.unexpected()"], test_result.failure_message_lines
-  end
-
-  def test_mock_object_explicitly_unexpected_invocation
-    execution_point = nil
-    test_result = run_as_test do
-      mock = mock("not expecting invocation")
-      mock.expects(:unexpected).never
-      execution_point = ExecutionPoint.current; mock.unexpected
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal [
-      "unexpected invocation: #<Mock:not expecting invocation>.unexpected()",
-      "unsatisfied expectations:",
-      "- expected never, invoked once: #<Mock:not expecting invocation>.unexpected(any_parameters)"
-    ], test_result.failure_message_lines
-  end
-
-  def test_mock_object_unsatisfied_expectation
-    execution_point = nil
-    test_result = run_as_test do
-      mock = mock("expecting invocation")
-      execution_point = ExecutionPoint.current; mock.expects(:expected)
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal [
-      "not all expectations were satisfied",
-      "unsatisfied expectations:",
-      "- expected exactly once, not yet invoked: #<Mock:expecting invocation>.expected(any_parameters)"
-    ], test_result.failure_message_lines
-  end
-
-  def test_mock_object_unexpected_invocation_in_setup
-    execution_point = nil
-    test_result = run_as_tests(
-      :setup => lambda {
-        mock = mock("not expecting invocation")
-        execution_point = ExecutionPoint.current; mock.unexpected
-      },
-      :test_me => lambda {
-        assert true
-      }
-    )
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal ["unexpected invocation: #<Mock:not expecting invocation>.unexpected()"], test_result.failure_message_lines
-  end
-
-  def test_mock_object_unsatisfied_expectation_in_setup
-    execution_point = nil
-    test_result = run_as_tests(
-      :setup => lambda {
-        mock = mock("expecting invocation")
-        execution_point = ExecutionPoint.current; mock.expects(:expected)
-      },
-      :test_me => lambda {
-        assert true
-      }
-    )
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal [
-      "not all expectations were satisfied",
-      "unsatisfied expectations:",
-      "- expected exactly once, not yet invoked: #<Mock:expecting invocation>.expected(any_parameters)"
-    ], test_result.failure_message_lines
-  end
-
-  def test_mock_object_unexpected_invocation_in_teardown
-    execution_point = nil
-    test_result = run_as_tests(
-      :test_me => lambda {
-        assert true
-      },
-      :teardown => lambda {
-        mock = mock("not expecting invocation")
-        execution_point = ExecutionPoint.current; mock.unexpected
-      }
-    )
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal ["unexpected invocation: #<Mock:not expecting invocation>.unexpected()"], test_result.failure_message_lines
-  end
-
-  def test_real_object_explicitly_unexpected_invocation
-    execution_point = nil
-    object = Object.new
-    test_result = run_as_test do
-      object.expects(:unexpected).never
-      execution_point = ExecutionPoint.current; object.unexpected
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal [
-      "unexpected invocation: #{object.mocha_inspect}.unexpected()",
-      "unsatisfied expectations:",
-      "- expected never, invoked once: #{object.mocha_inspect}.unexpected(any_parameters)"
-    ], test_result.failure_message_lines
-  end
-
-  def test_real_object_unsatisfied_expectation
-    execution_point = nil
-    object = Object.new
-    test_result = run_as_test do
-      execution_point = ExecutionPoint.current; object.expects(:expected)
-    end
-    assert_failed(test_result)
-    failure = test_result.failures.first
-    assert_equal execution_point, ExecutionPoint.new(failure.location)
-    assert_equal [
-      "not all expectations were satisfied",
-      "unsatisfied expectations:",
-      "- expected exactly once, not yet invoked: #{object.mocha_inspect}.expected(any_parameters)"
-    ], test_result.failure_message_lines
-  end
-
-  def test_real_object_expectation_does_not_leak_into_subsequent_test
-    execution_point = nil
-    klass = Class.new
-    test_result = run_as_tests(
-      :test_1 => lambda {
-        klass.expects(:foo)
-        klass.foo
-      },
-      :test_2 => lambda {
-        execution_point = ExecutionPoint.current; klass.foo
-      }
-    )
-    assert_failed(test_result)
-    exception = test_result.errors.first.exception
-    assert_equal execution_point, ExecutionPoint.new(exception.backtrace)
-    assert_match %r{undefined method `foo'}, exception.message
-  end
-end

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,24 +0,0 @@
-require 'metaclass'
-
-module Mocha
-
-  module ObjectMethods
-    def define_instance_method(method_symbol, &block)
-      __metaclass__.send(:define_method, method_symbol, block)
-    end
-
-    def replace_instance_method(method_symbol, &block)
-      raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless self.respond_to?(method_symbol)
-      define_instance_method(method_symbol, &block)
-    end
-
-    def define_instance_accessor(*symbols)
-      symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
-    end
-  end
-
-end
-
-class Object
-  include Mocha::ObjectMethods
-end

data/test/mini_test_result.rb

@@ -1,90 +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 = %r{(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n}m
-    ERROR_PATTERN   = %r{(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n}m
-    PATTERN_INDICES = { :method => 2, :testcase => 3 }
-  else
-    FAILURE_PATTERN = %r{(Failure)\:\n.([^#]+)\#([^ ]+) \[([^\]]+)\]\:\n(.*)\n}m
-    ERROR_PATTERN   = %r{(Error)\:\n.([^#]+)\#([^ ]+)\:\n(.+?)\n}m
-    PATTERN_INDICES = { :method => 3, :testcase => 2 }
-  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, @test_case, @location, @message = method, test_case, location, message
-    end
-  end
-
-  class Error
-    class Exception
-      attr_reader :message, :backtrace
-      def initialize(message, location)
-        @message, @backtrace = message, location
-      end
-    end
-
-    attr_reader :method, :test_case, :exception
-    def initialize(method, test_case, message, backtrace)
-      @method, @test_case, @exception = method, test_case, Exception.new(message, backtrace)
-    end
-  end
-
-  def initialize(runner, tests)
-    @runner, @tests = runner, 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,49 +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| Minitest::Assertion === r }.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| Minitest::UnexpectedError === r }
-  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,13 +0,0 @@
-class SimpleCounter
-
-  attr_reader :count
-
-  def initialize
-    @count = 0
-  end
-
-  def increment
-    @count += 1
-  end
-
-end

data/test/test_helper.rb

@@ -1,50 +0,0 @@
-unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
-  STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.instance_methods + Object.private_instance_methods
-end
-
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
-
-require 'mocha/detection/mini_test'
-
-begin
-  require 'minitest'
-rescue LoadError
-end
-begin
-  require 'minitest/unit'
-rescue LoadError
-end
-
-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
-  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
-else
-  require 'test/unit'
-  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
-end