redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/test/method_definer.rb

@@ -0,0 +1,18 @@
+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/lib/openssl/mocha/test/test_helper.rb

@@ -0,0 +1,12 @@
+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/lib/openssl/mocha/test/test_runner.rb

@@ -0,0 +1,31 @@
+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.first.message}" if test_result.failure_count > 0
+    flunk "Test failed unexpectedly with message: #{test_result.errors.first.message}" if test_result.error_count > 0
+  end
+
+  def assert_failed(test_result)
+    flunk "Test passed unexpectedly" if test_result.passed?
+  end
+
+end

data/lib/openssl/mocha/test/unit/any_instance_method_test.rb

@@ -0,0 +1,124 @@
+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.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.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/lib/openssl/mocha/test/unit/array_inspect_test.rb

@@ -0,0 +1,16 @@
+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

data/lib/openssl/mocha/test/unit/auto_verify_test.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/auto_verify'
+require 'method_definer'
+
+class AutoVerifyTest < Test::Unit::TestCase
+  
+  attr_reader :test_case
+  
+  def setup
+    @test_case = Object.new
+    class << test_case
+      def self.add_teardown_method(symbol); end
+      include Mocha::AutoVerify
+    end
+  end
+  
+  def test_should_build_mock
+    mock = test_case.mock
+    assert mock.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectations_to_mock
+    mock = test_case.mock(:method_1 => 'result_1', :method_2 => 'result_2')
+    assert_equal 'result_1', mock.method_1
+    assert_equal 'result_2', mock.method_2
+  end
+  
+  def test_should_build_stub
+    stub = test_case.stub
+    assert stub.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_add_expectation_to_stub
+    stub = test_case.stub(:method_1 => 'result_1', :method_2 => 'result_2')
+    assert_equal 'result_1', stub.method_1
+    assert_equal 'result_2', stub.method_2
+  end
+  
+  def test_should_build_stub_that_stubs_all_methods
+    stub = test_case.stub_everything
+    assert stub.stub_everything
+  end
+  
+  def test_should_add_expectations_to_stub_that_stubs_all_methods
+    stub = test_case.stub_everything(:method_1 => 'result_1', :method_2 => 'result_2')
+    assert_equal 'result_1', stub.method_1
+    assert_equal 'result_2', stub.method_2
+  end
+  
+  def test_should_always_new_mock
+    assert_not_equal test_case.mock, test_case.mock
+  end
+  
+  def test_should_always_build_new_stub
+    assert_not_equal test_case.stub, test_case.stub
+  end
+  
+  def test_should_always_build_new_stub_that_stubs_all_methods
+    assert_not_equal test_case.stub, test_case.stub
+  end
+  
+  def test_should_store_each_new_mock
+    expected = Array.new(3) { test_case.mock }
+    assert_equal expected, test_case.mocks
+  end
+  
+  def test_should_store_each_new_stub
+    expected = Array.new(3) { test_case.stub }
+    assert_equal expected, test_case.mocks
+  end
+  
+  def test_should_store_each_new_stub_that_stubs_all_methods
+    expected = Array.new(3) { test_case.stub_everything }
+    assert_equal expected, test_case.mocks
+  end
+  
+  def test_should_verify_each_mock
+    mocks = Array.new(3) do
+      mock = Object.new
+      mock.define_instance_accessor(:verify_called)
+      mock.define_instance_method(:verify) { self.verify_called = true }
+      mock
+    end
+    test_case.replace_instance_method(:mocks)  { mocks }
+    test_case.verify_mocks
+    assert mocks.all? { |mock| mock.verify_called }
+  end
+  
+  def test_should_yield_to_block_for_each_assertion
+    mock_class = Class.new do
+      def verify(&block); yield; end
+    end
+    mock = mock_class.new
+    test_case.replace_instance_method(:mocks)  { [mock] }
+    yielded = false
+    test_case.verify_mocks { yielded = true }
+    assert yielded
+  end
+  
+  def test_should_reset_mocks_on_teardown
+    mock = Class.new { define_method(:verify) {} }.new
+    test_case.mocks << mock
+    test_case.teardown_mocks
+    assert test_case.mocks.empty?
+  end
+  
+  def test_should_create_named_mock
+    mock = test_case.mock('named_mock')
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
+  end
+  
+  def test_should_create_named_stub
+    stub = test_case.stub('named_stub')
+    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
+  end
+  
+  def test_should_create_named_stub_that_stubs_all_methods
+    stub = test_case.stub_everything('named_stub')
+    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
+  end
+  
+end

data/lib/openssl/mocha/test/unit/central_test.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/central'
+require 'mocha/mock'
+require 'method_definer'
+
+class CentralTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_start_with_empty_stubba_methods
+    stubba = Central.new
+    
+    assert_equal [], stubba.stubba_methods
+  end
+  
+  def test_should_stub_method_if_not_already_stubbed
+    method = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    method.verify
+  end
+  
+  def test_should_not_stub_method_if_already_stubbed
+    method = Mock.new
+    method.expects(:stub).times(0)
+    stubba = Central.new
+    stubba_methods = Mock.new
+    stubba_methods.stubs(:include?).with(method).returns(true)
+    stubba.stubba_methods = stubba_methods
+    
+    stubba.stub(method)
+    
+    method.verify
+  end
+  
+  def test_should_record_method
+    method = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    assert_equal [method], stubba.stubba_methods
+  end
+  
+  def test_should_unstub_all_methods
+    stubba = Central.new
+    method_1 = Mock.new
+    method_1.expects(:unstub)
+    method_2 = Mock.new
+    method_2.expects(:unstub)
+    stubba.stubba_methods = [method_1, method_2]
+
+    stubba.unstub_all
+    
+    assert_equal [], stubba.stubba_methods
+    method_1.verify
+    method_2.verify
+  end
+  
+  def test_should_collect_mocks_from_all_methods
+    method_1 = Mock.new
+    method_1.stubs(:mock).returns(:mock_1)
+
+    method_2 = Mock.new
+    method_2.stubs(:mock).returns(:mock_2)
+
+    stubba = Central.new
+    stubba.stubba_methods = [method_1, method_2]
+    
+    assert_equal 2, stubba.unique_mocks.size
+    assert stubba.unique_mocks.include?(:mock_1)
+    assert stubba.unique_mocks.include?(:mock_2)
+  end
+
+  def test_should_return_unique_mochas
+    method_1 = Mock.new
+    method_1.stubs(:mock).returns(:mock_1)
+
+    method_2 = Mock.new
+    method_2.stubs(:mock).returns(:mock_1)
+
+    stubba = Central.new
+    stubba.stubba_methods = [method_1, method_2]
+    
+    assert_equal [:mock_1], stubba.unique_mocks
+  end
+  
+  def test_should_call_verify_on_all_unique_mocks
+    mock_class = Class.new do
+      attr_accessor :verify_called
+      def verify
+        self.verify_called = true
+      end
+    end
+    mocks = [mock_class.new, mock_class.new]
+    stubba = Central.new
+    stubba.replace_instance_method(:unique_mocks) { mocks }
+    
+    stubba.verify_all
+    
+    assert mocks.all? { |mock| mock.verify_called }
+  end
+
+  def test_should_call_verify_on_all_unique_mochas
+    mock_class = Class.new do
+      def verify(&block)
+        yield if block_given?
+      end
+    end
+    stubba = Central.new
+    stubba.replace_instance_method(:unique_mocks) { [mock_class.new] }
+    yielded = false
+    
+    stubba.verify_all { yielded = true }
+    
+    assert yielded
+  end
+
+end