mocha 0.5.6 → 3.1.0

data/test/active_record_test_case.rb

@@ -1,36 +0,0 @@
-module ActiveRecordTestCase
-
-  def setup_with_fixtures
-    methods_called << :setup_with_fixtures
-  end
-
-  alias_method :setup, :setup_with_fixtures
-
-  def teardown_with_fixtures
-    methods_called << :teardown_with_fixtures
-  end
-
-  alias_method :teardown, :teardown_with_fixtures
-
-  def self.method_added(method)
-    case method.to_s
-    when 'setup'
-      unless method_defined?(:setup_without_fixtures)
-        alias_method :setup_without_fixtures, :setup
-        define_method(:setup) do
-          setup_with_fixtures
-          setup_without_fixtures
-        end
-      end
-    when 'teardown'
-      unless method_defined?(:teardown_without_fixtures)
-        alias_method :teardown_without_fixtures, :teardown
-        define_method(:teardown) do
-          teardown_without_fixtures
-          teardown_with_fixtures
-        end
-      end
-    end
-  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,34 +0,0 @@
-class ExecutionPoint
-  
-  attr_reader :backtrace
-
-  def self.current
-    new(caller)
-  end
-  
-  def initialize(backtrace)
-    @backtrace = backtrace
-  end
-  
-  def file_name
-    /\A(.*?):\d+/.match(@backtrace.first)[1]
-  end
-  
-  def line_number
-    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/mocha_test_result_integration_test.rb

@@ -1,105 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/standalone'
-require 'mocha/test_case_adapter'
-require 'execution_point'
-
-class MochaTestResultIntegrationTest < Test::Unit::TestCase
-  
-  def test_should_include_expectation_verification_in_assertion_count
-    test_result = run_test do
-      object = mock()
-      object.expects(:message)
-      object.message
-    end
-    assert_equal 1, test_result.assertion_count
-  end
-  
-  def test_should_include_assertions_in_assertion_count
-    test_result = run_test do
-      assert true
-    end
-    assert_equal 1, test_result.assertion_count
-  end
-  
-  def test_should_not_include_stubbing_expectation_verification_in_assertion_count
-    test_result = run_test do
-      object = mock()
-      object.stubs(:message)
-      object.message
-    end
-    assert_equal 0, test_result.assertion_count
-  end
-  
-  def test_should_include_expectation_verification_failure_in_failure_count
-    test_result = run_test do
-      object = mock()
-      object.expects(:message)
-    end
-    assert_equal 1, test_result.failure_count
-  end
-  
-  def test_should_include_unexpected_verification_failure_in_failure_count
-    test_result = run_test do
-      object = mock()
-      object.message
-    end
-    assert_equal 1, test_result.failure_count
-  end
-  
-  def test_should_include_assertion_failure_in_failure_count
-    test_result = run_test do
-      flunk
-    end
-    assert_equal 1, test_result.failure_count
-  end
-  
-  def test_should_display_backtrace_indicating_line_number_where_expects_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      object = mock()
-      execution_point = ExecutionPoint.current; object.expects(:message)
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def test_should_display_backtrace_indicating_line_number_where_unexpected_method_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      object = mock()
-      execution_point = ExecutionPoint.current; object.message 
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def test_should_display_backtrace_indicating_line_number_where_failing_assertion_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      execution_point = ExecutionPoint.current; flunk
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def run_test(test_result = Test::Unit::TestResult.new, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      define_method(:test_me, &block)
-    end
-    test = test_class.new(:test_me)
-    test.run(test_result) {}
-    test_result
-  end
-  
-end

data/test/integration/stubba_integration_test.rb

@@ -1,89 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-
-require 'mocha/object'
-require 'mocha/test_case_adapter'
-require 'mocha/standalone'
-
-class StubbaIntegrationTest < Test::Unit::TestCase
-  
-  class DontMessWithMe
-    def self.my_class_method
-      :original_return_value
-    end
-    def my_instance_method
-      :original_return_value
-    end
-  end
-  
-  def test_should_stub_class_method_within_test
-    test = build_test do
-      DontMessWithMe.expects(:my_class_method).returns(:new_return_value)
-      assert_equal :new_return_value, DontMessWithMe.my_class_method
-    end
-
-    test_result = Test::Unit::TestResult.new
-    test.run(test_result) {}
-    assert test_result.passed?
-  end
-
-  def test_should_leave_stubbed_class_method_unchanged_after_test
-    test = build_test do
-      DontMessWithMe.expects(:my_class_method).returns(:new_return_value)
-    end
-
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal :original_return_value, DontMessWithMe.my_class_method
-  end
-  
-  def test_should_reset_class_expectations_after_test
-    test = build_test do
-      DontMessWithMe.expects(:my_class_method)
-    end
-    
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal 0, DontMessWithMe.mocha.expectations.length
-  end  
-
-  def test_should_stub_instance_method_within_test
-    instance = DontMessWithMe.new
-    test = build_test do
-      instance.expects(:my_instance_method).returns(:new_return_value)
-      assert_equal :new_return_value, instance.my_instance_method
-    end
-    test_result = Test::Unit::TestResult.new
-    test.run(test_result) {}
-    assert test_result.passed?
-  end
-  
-  def test_should_leave_stubbed_instance_method_unchanged_after_test
-    instance = DontMessWithMe.new
-    test = build_test do
-      instance.expects(:my_instance_method).returns(:new_return_value)
-    end
-
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal :original_return_value, instance.my_instance_method
-  end
-  
-  def test_should_reset_instance_expectations_after_test
-    instance = DontMessWithMe.new
-    test = build_test do
-      instance.expects(:my_instance_method).returns(:new_return_value)
-    end
-    
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal 0, instance.mocha.expectations.length
-  end  
-
-  private
-
-  def build_test(&block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      define_method(:test_me, &block)
-    end
-    test_class.new(:test_me)
-  end
-
-end

data/test/integration/stubba_test_result_integration_test.rb

@@ -1,85 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/object'
-require 'mocha/standalone'
-require 'mocha/test_case_adapter'
-require 'execution_point'
-
-class StubbaTestResultIntegrationTest < Test::Unit::TestCase
-
-  def test_should_include_expectation_verification_in_assertion_count
-    test_result = run_test do
-      object = Class.new { def message; end }.new
-      object.expects(:message)
-      object.message
-    end
-    assert_equal 1, test_result.assertion_count
-  end
-  
-  def test_should_include_assertions_in_assertion_count
-    test_result = run_test do
-      assert true
-    end
-    assert_equal 1, test_result.assertion_count
-  end
-  
-  def test_should_not_include_stubbing_expectation_verification_in_assertion_count
-    test_result = run_test do
-      object = Class.new { def message; end }.new
-      object.stubs(:message)
-      object.message
-    end
-    assert_equal 0, test_result.assertion_count
-  end
-  
-  def test_should_include_expectation_verification_failure_in_failure_count
-    test_result = run_test do
-      object = Class.new { def message; end }.new
-      object.expects(:message)
-    end
-    assert_equal 1, test_result.failure_count
-  end
-  
-  def test_should_include_assertion_failure_in_failure_count
-    test_result = run_test do
-      flunk
-    end
-    assert_equal 1, test_result.failure_count
-  end
-  
-  def test_should_display_backtrace_indicating_line_number_where_expects_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      object = Class.new { def message; end }.new
-      execution_point = ExecutionPoint.current; object.expects(:message)
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def test_should_display_backtrace_indicating_line_number_where_failing_assertion_was_called
-    test_result = Test::Unit::TestResult.new
-    faults = []
-    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
-    execution_point = nil
-    run_test(test_result) do
-      execution_point = ExecutionPoint.current; flunk
-    end
-    assert_equal 1, faults.length
-    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
-  end
-  
-  def run_test(test_result = Test::Unit::TestResult.new, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      define_method(:test_me, &block)
-    end
-    test = test_class.new(:test_me)
-    test.run(test_result) {}
-    test_result
-  end
-  
-end

data/test/method_definer.rb

@@ -1,18 +0,0 @@
-require 'mocha/metaclass'
-
-class Object
-  
-  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

data/test/test_helper.rb

@@ -1,12 +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__), 'integration'))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
-
-require 'test/unit'

data/test/test_runner.rb

@@ -1,31 +0,0 @@
-require 'test/unit/testresult'
-require 'test/unit/testcase'
-require 'mocha/standalone'
-require 'mocha/test_case_adapter'
-
-module TestRunner
-  
-  def run_test(test_result = Test::Unit::TestResult.new, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      include Mocha::Standalone
-      include Mocha::TestCaseAdapter
-      define_method(:test_me, &block)
-    end
-    test = test_class.new(:test_me)
-    test.run(test_result) {}
-    class << test_result
-      attr_reader :failures, :errors
-    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,126 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-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 = Mock.new
-    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
-    mocha.verify
-  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 = Mock.new
-    any_instance.stubs(:reset_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 = Mock.new
-    any_instance.stubs(:reset_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_reset_mocha
-    klass = Class.new { def method_x; end }
-    any_instance = Class.new { attr_accessor :mocha_was_reset; def reset_mocha; self.mocha_was_reset = true; end }.new
-    klass.define_instance_method(:any_instance) { any_instance }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
-    
-    method.unstub
-
-    assert any_instance.mocha_was_reset
-  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
-
-end

data/test/unit/array_inspect_test.rb

@@ -1,16 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/inspect'
-
-class ArrayInstanceTest < 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