mocha 0.1

data/test/stubba/any_instance_method_test.rb

@@ -0,0 +1,113 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/mock'
+
+require 'stubba/any_instance_method'
+
+class AnyInstanceMethodTest < Test::Unit::TestCase
+  
+  include Stubba
+  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 = Mock.new(: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(:reset_mocha => nil)
+    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(:reset_mocha => nil)
+    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 = Mock.new(:reset_mocha => nil)
+    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
+
+    any_instance.verify(:reset_mocha)
+  end
+
+end

data/test/stubba/class_method_test.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/mock'
+
+require 'stubba/class_method'
+
+class ClassMethodTest < Test::Unit::TestCase
+  
+  include Stubba
+  include Mocha
+
+  def test_should_provide_hidden_version_of_method_name
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_equal '__stubba__original_method_name__stubba__', method.hidden_method
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_with_question_mark
+    method = ClassMethod.new(nil, :original_method_name?)
+    assert_equal '__stubba__original_method_name_question_mark__stubba__', method.hidden_method
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_with_exclamation_mark
+    method = ClassMethod.new(nil, :original_method_name!)
+    assert_equal '__stubba__original_method_name_exclamation_mark__stubba__', method.hidden_method
+  end
+  
+  def test_should_hide_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_not_hide_original_method_if_method_not_defined
+    klass = Class.new
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert_equal false, klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_define_a_new_method_which_should_call_mocha_method_missing
+    klass = Class.new { def self.method_x; end }
+    mocha = Mock.new
+    klass.define_instance_method(:mocha) { mocha }
+    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
+    method = ClassMethod.new(klass, :method_x)
+    
+    method.define_new_method
+    result = klass.method_x(:param1, :param2)
+    
+    assert_equal :result, result
+    mocha.verify
+  end
+  
+  def test_should_remove_new_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    
+    method.remove_new_method
+    
+    assert_equal false, klass.respond_to?(:method_x)
+  end
+
+  def test_should_restore_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    klass.define_instance_method(hidden_method_x) { :original_result }
+
+    method.restore_original_method
+    
+    assert_equal :original_result, klass.method_x 
+    assert !klass.respond_to?(hidden_method_x)
+  end
+
+  def test_should_not_restore_original_method_if_hidden_method_is_not_defined
+    klass = Class.new { def self.method_x; :new_result; end }
+    method = ClassMethod.new(klass, :method_x)
+
+    method.restore_original_method
+    
+    assert_equal :new_result, klass.method_x
+  end
+
+  def test_should_call_hide_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:hide_called)
+    method.replace_instance_method(:hide_original_method) { self.hide_called = true }
+    
+    method.stub
+    
+    assert method.hide_called
+  end
+
+  def test_should_call_define_new_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:define_called)
+    method.replace_instance_method(:define_new_method) { self.define_called = true }
+    
+    method.stub
+    
+    assert method.define_called
+  end
+  
+  def test_should_call_remove_new_method
+    klass = Class.new { def self.method_x; end }
+    klass.define_instance_method(:reset_mocha) { }
+    method = ClassMethod.new(klass, :method_x)
+    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 self.method_x; end }
+    klass.define_instance_method(:reset_mocha) { }
+    method = ClassMethod.new(klass, :method_x)
+    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 self.method_x; end }
+    klass.define_instance_accessor(:reset_called)
+    klass.define_instance_method(:reset_mocha) { self.reset_called = true }
+    method = ClassMethod.new(klass, :method_x)
+    method.replace_instance_method(:restore_original_method) { }
+    
+    method.unstub
+    
+    assert klass.reset_called
+  end
+
+end

data/test/stubba/instance_method_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+
+require 'stubba/instance_method'
+
+class InstanceMethodTest < Test::Unit::TestCase
+  
+  include Stubba
+   
+  def test_should_exist
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :method_x)
+    
+    assert method.exists?
+  end
+  
+  def test_should_not_exist
+    klass = Class.new { }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :non_existent_method)
+    
+    assert !method.exists?
+  end
+  
+  def test_should_raise_assertion_failed_error_when_attempting_to_stub_non_existent_method
+    klass = Class.new
+    instance = klass.new
+    method = InstanceMethod.new(instance, :non_existent_method)
+    assert_raise(Test::Unit::AssertionFailedError) { method.stub }
+  end
+  
+  def test_should_call_define_new_method
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :method_x)
+    method.define_instance_accessor(:define_called)
+    method.replace_instance_method(:define_new_method) { self.define_called = true }
+    
+    method.stub
+    
+    assert method.define_called
+  end
+    
+  def test_should_not_call_hide_original_method
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :method_x)
+    method.replace_instance_method(:define_new_method) { }
+    method.define_instance_accessor(:hide_called)
+    method.replace_instance_method(:hide_original_method) { self.hide_called = true }
+    
+    method.stub
+    
+    assert !method.hide_called
+  end
+    
+  def test_should_not_call_restore_original_method
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :method_x)
+    method.replace_instance_method(:define_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_not_call_remove_new_method
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    method = InstanceMethod.new(instance, :method_x)
+    method.replace_instance_method(:define_new_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_not_call_reset_mocha
+    klass = Class.new { def method_x; end }
+    instance = klass.new
+    instance.define_instance_accessor(:reset_called)
+    instance.define_instance_method(:reset_mocha) { self.reset_called = true }
+    method = InstanceMethod.new(instance, :method_x)
+    method.replace_instance_method(:define_new_method) { }
+    
+    method.unstub
+    
+    assert !instance.reset_called
+  end
+  
+end

data/test/stubba/object_test.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'stubba_replacer'
+
+require 'stubba/object'
+
+class ObjectTest < Test::Unit::TestCase
+  
+  include Stubba
+  include Mocha
+  
+  def test_should_build_mocha
+    instance = Object.new
+    mocha = instance.mocha
+    assert_not_nil mocha
+    assert mocha.is_a?(Mock)
+  end
+  
+  def test_should_reuse_existing_mocha
+    instance = Object.new
+    mocha_1 = instance.mocha
+    mocha_2 = instance.mocha
+    assert_equal mocha_1, mocha_2
+  end
+  
+  def test_should_reset_mocha
+    instance = Object.new
+    assert_nil instance.reset_mocha
+  end
+  
+  def test_should_stub_instance_method
+    instance = Object.new
+    stubba = Mock.new
+    stubba.expects(:stub).with(InstanceMethod.new(instance, :method1))
+    replace_stubba(stubba) do
+      instance.expects(:method1)
+    end
+    stubba.verify(:stub)
+  end 
+  
+  def test_should_build_and_store_expectation
+    instance = Object.new
+    stubba = Mock.new(:stub => nil)
+    replace_stubba(stubba) do
+      expectation = instance.expects(:method1)
+      assert_equal [expectation], instance.mocha.expectations
+    end
+  end
+  
+  def test_should_verify_expectations
+    instance = Object.new
+    stubba = Mock.new(:stub => nil)
+    replace_stubba(stubba) do
+      instance.expects(:method1).with(:value1, :value2)
+    end
+    assert_raise(Test::Unit::AssertionFailedError) { instance.verify }
+  end
+  
+  def test_should_build_any_instance_object
+    klass = Class.new
+    any_instance = klass.any_instance
+    assert_not_nil any_instance
+    assert any_instance.is_a?(Class::AnyInstance)
+  end
+  
+  def test_should_return_same_any_instance_object
+    klass = Class.new
+    any_instance_1 = klass.any_instance
+    any_instance_2 = klass.any_instance
+    assert_equal any_instance_1, any_instance_2
+  end
+  
+  def test_should_stub_class_method
+    klass = Class.new
+    stubba = Mock.new
+    stubba.expects(:stub).with(ClassMethod.new(klass, :method1))
+    replace_stubba(stubba) do
+      klass.expects(:method1)
+    end
+    stubba.verify(:stub)
+  end 
+  
+  def test_should_build_and_store_class_method_expectation
+    klass = Class.new
+    stubba = Mock.new(:stub => nil)
+    replace_stubba(stubba) do
+      expectation = klass.expects(:method1)
+      assert_equal [expectation], klass.mocha.expectations
+    end
+  end
+  
+  def test_should_stub_module_method
+    mod = Module.new
+    stubba = Mock.new
+    stubba.expects(:stub).with(ClassMethod.new(mod, :method1))
+    replace_stubba(stubba) do
+      mod.expects(:method1)
+    end
+    stubba.verify(:stub)
+  end
+  
+  def test_should_build_and_store_module_method_expectation
+    mod = Module.new
+    stubba = Mock.new(:stub => nil)
+    replace_stubba(stubba) do
+      expectation = mod.expects(:method1)
+      assert_equal [expectation], mod.mocha.expectations
+    end
+  end
+  
+  def test_should_use_stubba_instance_method_for_object
+    assert_equal InstanceMethod, Object.new.stubba_method
+  end
+    
+  def test_should_use_stubba_class_method_for_module
+    assert_equal ClassMethod, Module.new.stubba_method
+  end
+    
+  def test_should_use_stubba_class_method_for_class
+    assert_equal ClassMethod, Class.new.stubba_method
+  end
+  
+  def test_should_use_stubba_class_method_for_any_instance
+    assert_equal AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
+  end
+  
+  def test_should_stub_self_for_object
+    object = Object.new
+    assert_equal object, object.stubba_object
+  end
+      
+  def test_should_stub_self_for_module
+    mod = Module.new
+    assert_equal mod, mod.stubba_object
+  end
+      
+  def test_should_stub_self_for_class
+    klass = Class.new
+    assert_equal klass, klass.stubba_object
+  end
+      
+  def test_should_stub_relevant_class_for_any_instance
+    klass = Class.new
+    any_instance = Class::AnyInstance.new(klass)
+    assert_equal klass, any_instance.stubba_object
+  end
+      
+end