mocha 0.10.5 → 1.13.0

data/test/acceptance/unstubbing_test.rb

@@ -1,151 +0,0 @@
-require File.expand_path('../acceptance_test_helper', __FILE__)
-require 'mocha'
-
-class UnstubbingTest < Test::Unit::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_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/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/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,83 +0,0 @@
-require 'stringio'
-require 'test/unit/testcase'
-require 'minitest/unit'
-
-class MiniTestResult
-  
-  FAILURE_PATTERN = %r{(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n}m
-  ERROR_PATTERN   = %r{(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n}m
-  
-  def self.parse_failure(raw)
-    matches = FAILURE_PATTERN.match(raw)
-    return nil unless matches
-    Failure.new(matches[2], matches[3], [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[2], matches[3], 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, test)
-    @runner, @test = runner, test
-  end
-  
-  def failure_count
-    @runner.failures
-  end
-  
-  def assertion_count
-    @test._assertions
-  end
-  
-  def error_count
-    @runner.errors
-  end
-  
-  def passed?
-    @test.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/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,11 +0,0 @@
-unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
-  STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.public_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 'test/unit'

data/test/test_runner.rb

@@ -1,50 +0,0 @@
-require 'test/unit/testcase'
-
-if defined?(MiniTest)
-  require 'mocha/integration/mini_test'
-  require File.expand_path('../mini_test_result', __FILE__)
-else
-  require 'test/unit/testresult'
-end
-
-module TestRunner
-  def run_as_test(test_result = nil, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      define_method(:test_me, &block)
-    end
-    test = test_class.new(:test_me)
-    
-    if defined?(Test::Unit::TestResult)
-      test_result ||= Test::Unit::TestResult.new
-      test.run(test_result) {}
-      class << test_result
-        attr_reader :failures, :errors
-        def failure_messages
-          failures.map { |failure| failure.message }
-        end
-        def failure_message_lines
-          failure_messages.map { |message| message.split("\n") }.flatten
-        end
-        def error_messages
-          errors.map { |error| error.message }
-        end
-      end
-    else
-      runner = MiniTest::Unit.new
-      test.run(runner)
-      test_result = MiniTestResult.new(runner, test)
-    end
-    
-    test_result
-  end
-  
-  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}" if test_result.error_count > 0
-  end
-
-  def assert_failed(test_result)
-    flunk "Test passed unexpectedly" if test_result.passed?
-  end
-
-end

data/test/unit/any_instance_method_test.rb

@@ -1,136 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/mock'
-require 'mocha/any_instance_method'
-
-class AnyInstanceMethodTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_hide_original_method
-    klass = Class.new { def method_x; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    
-    method.hide_original_method
-    
-    assert klass.method_defined?(hidden_method_x)
-  end
-  
-  def test_should_not_hide_original_method_if_it_is_not_defined
-    klass = Class.new
-    method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    
-    method.hide_original_method
-    
-    assert_equal false, klass.method_defined?(hidden_method_x)
-  end
-  
-  def test_should_define_a_new_method
-    klass = Class.new { def method_x; end } 
-    method = AnyInstanceMethod.new(klass, :method_x)
-    mocha = build_mock
-    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    any_instance = Object.new
-    any_instance.define_instance_method(:mocha) { mocha }
-    klass.define_instance_method(: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_restore_original_method
-    klass = Class.new { def method_x; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    klass.send(:define_method, hidden_method_x, Proc.new { :original_result }) 
-    
-    method.remove_new_method
-    method.restore_original_method
-    
-    instance = klass.new
-    assert_equal :original_result, instance.method_x 
-    assert !klass.method_defined?(hidden_method_x)
-  end
-
-  def test_should_not_restore_original_method_if_hidden_method_not_defined
-    klass = Class.new { def method_x; :new_result; end }
-    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.new { def method_x; end }
-    any_instance = build_mock
-    any_instance_mocha = build_mock
-    any_instance.stubs(:mocha).returns(any_instance_mocha)
-    klass.define_instance_method(:any_instance) { any_instance }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    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 method_x; end }
-    any_instance = build_mock
-    any_instance_mocha = build_mock
-    any_instance.stubs(:mocha).returns(any_instance_mocha)
-    klass.define_instance_method(:any_instance) { any_instance }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    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_mock_unstub
-    klass = Class.new { def method_x; end }
-
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    method.replace_instance_method(:remove_new_method) { }
-    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_return_any_instance_mocha_for_stubbee
-    mocha = Object.new
-    any_instance = Object.new
-    any_instance.define_instance_method(:mocha) { mocha }
-    stubbee = Class.new
-    stubbee.define_instance_method(: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

data/test/unit/array_inspect_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class ArrayInspectTest < Test::Unit::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,19 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/backtrace_filter'
-
-class BacktraceFilterTest < Test::Unit::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,56 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/cardinality'
-
-class CardinalityTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
-    cardinality = Cardinality.new(2, 3)
-    assert cardinality.invocations_allowed?(0)
-    assert cardinality.invocations_allowed?(1)
-    assert cardinality.invocations_allowed?(2)
-    assert !cardinality.invocations_allowed?(3)
-  end
-  
-  def test_should_be_satisfied_if_invocations_so_far_have_reached_required_threshold
-    cardinality = Cardinality.new(2, 3)
-    assert !cardinality.satisfied?(0)
-    assert !cardinality.satisfied?(1)
-    assert cardinality.satisfied?(2)
-    assert cardinality.satisfied?(3)
-  end
-  
-  def test_should_describe_cardinality
-    assert_equal 'allowed any number of times', Cardinality.at_least(0).mocha_inspect
-    
-    assert_equal 'expected at most once', Cardinality.at_most(1).mocha_inspect
-    assert_equal 'expected at most twice', Cardinality.at_most(2).mocha_inspect
-    assert_equal 'expected at most 3 times', Cardinality.at_most(3).mocha_inspect
-    
-    assert_equal 'expected at least once', Cardinality.at_least(1).mocha_inspect
-    assert_equal 'expected at least twice', Cardinality.at_least(2).mocha_inspect
-    assert_equal 'expected at least 3 times', Cardinality.at_least(3).mocha_inspect
-    
-    assert_equal 'expected never', Cardinality.exactly(0).mocha_inspect
-    assert_equal 'expected exactly once', Cardinality.exactly(1).mocha_inspect
-    assert_equal 'expected exactly twice', Cardinality.exactly(2).mocha_inspect
-    assert_equal 'expected exactly 3 times', Cardinality.times(3).mocha_inspect
-    
-    assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).mocha_inspect
-    assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).mocha_inspect
-  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