mocha 0.1

data/test/auto_mocha/auto_mock_test.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'auto_mocha/auto_mock'
+
+class AutoMockTest < Test::Unit::TestCase
+  
+  def setup
+    reset_mochas
+  end
+  
+  def test_should_reset_mochas
+    undefined_class = UndefinedClass
+    reset_mochas
+    assert_not_same undefined_class, UndefinedClass
+  end
+  
+  def test_should_refer_to_same_class
+    defined_class = Class.new { def self.undefined_class; UndefinedClass; end }
+    assert_same UndefinedClass, defined_class.undefined_class
+  end
+  
+  def test_should_refer_to_same_parent_class
+    defined_class = Class.new(UndefinedClass)
+    assert_same UndefinedClass, defined_class.superclass
+  end
+  
+  def test_should_refer_to_same_namespaced_class
+    defined_class = Class.new { def self.namespaced_class; Namespace::UndefinedClass; end }
+    assert_same Namespace::UndefinedClass, defined_class.namespaced_class
+  end
+  
+  def test_should_refer_to_different_namespaced_classes_within_test
+    assert ! NamespaceOne::UndefinedClass.equal?(NamespaceTwo::UndefinedClass)
+  end
+     
+  def test_should_refer_to_different_namespaced_classes_within_class_under_test
+    defined_class = Class.new {
+      def self.class_in_namespace_one; NamespaceOne::UndefinedClass; end
+      def self.class_in_namespace_two; NamespaceTwo::UndefinedClass; end
+    }
+    assert ! defined_class.class_in_namespace_one.equal?(defined_class.class_in_namespace_two)
+  end
+  
+  def test_should_refer_to_same_class_within_instance_under_test
+    defined_class = Class.new(UndefinedClassOne) { def undefined_class_two; UndefinedClassTwo; end }
+    instance = defined_class.new
+    assert_same UndefinedClassTwo, instance.undefined_class_two
+  end
+  
+  def test_should_verify_all_root_mochas_when_second_method_is_not_called
+    ClassOne.expects(:first)
+    ClassTwo.expects(:second)
+    ClassOne.first
+    assert_raise(Test::Unit::AssertionFailedError) {
+      verify_all
+    }
+  end
+  
+  def test_should_verify_all_root_mochas_when_first_method_is_not_called
+    ClassOne.expects(:first)
+    ClassTwo.expects(:second)
+    ClassTwo.second
+    assert_raise(Test::Unit::AssertionFailedError) {
+      verify_all
+    }
+  end
+  
+  def test_should_verify_all_namespaced_mochas_when_second_method_is_not_called
+    NamespaceOne::ClassOne.expects(:first)
+    NamespaceTwo::ClassTwo.expects(:second)
+    NamespaceOne::ClassOne.first
+    assert_raise(Test::Unit::AssertionFailedError) {
+      verify_all
+    }
+  end
+  
+  def test_should_verify_all_namespaced_mochas_when_first_method_is_not_called
+    NamespaceOne::ClassOne.expects(:first)
+    NamespaceTwo::ClassTwo.expects(:second)
+    NamespaceTwo::ClassTwo.second
+    assert_raise(Test::Unit::AssertionFailedError) {
+      verify_all
+    }
+  end
+  
+end

data/test/auto_mocha/mock_class_test.rb

@@ -0,0 +1,179 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'auto_mocha/mock_class'
+
+class MockClassTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_not_expect_unexpected_class_method_call
+    klass = MockClass.dup
+    assert_raise(Test::Unit::AssertionFailedError) {
+      klass.unexpected_class_method
+    }
+  end
+  
+  def test_should_expect_expected_class_method_call
+    klass = MockClass.dup
+    klass.expects(:expected_class_method)
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      klass.expected_class_method
+    }
+  end
+  
+  def test_should_fail_verification_for_missing_class_method_call
+    klass = MockClass.dup
+    klass.expects(:expected_class_method)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      klass.verify
+    }
+  end
+   
+  def test_should_verify_expected_class_method_call
+    klass = MockClass.dup
+    klass.expects(:expected_class_method)
+    klass.expected_class_method
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      klass.verify
+    }
+  end
+  
+  def test_should_not_expect_unexpected_child_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      child_class.unexpected_child_class_method
+    }
+  end
+  
+  def test_should_expect_child_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_class.expects(:expected_child_class_method)
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      child_class.expected_child_class_method
+    }
+  end
+  
+  def test_should_fail_verification_for_missing_child_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_class.expects(:expected_child_class_method)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      child_class.verify
+    }
+  end
+  
+  def test_should_verify_expected_child_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_class.expects(:expected_child_class_method)
+    child_class.expected_child_class_method
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      child_class.verify
+    }
+  end
+  
+  def test_should_not_expect_unexpected_parent_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      child_class.unexpected_parent_class_method
+    }
+  end
+  
+  def test_should_expect_parent_class_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    parent_class.expects(:expected_parent_class_method)
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      child_class.expected_parent_class_method
+    }
+  end
+  
+  def test_should_fail_verification_for_missing_parent_class_method
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    parent_class.expects(:expected_parent_class_method)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      parent_class.verify
+    }
+  end
+  
+  def test_should_verify_expected_parent_class_method_call_from_child_class
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    parent_class.expects(:expected_parent_class_method)
+    child_class.expected_parent_class_method
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      parent_class.verify
+    }
+  end
+  
+  def test_should_have_different_expectations_for_different_descendant_classes
+    klass1 = MockClass.dup
+    klass2 = MockClass.dup
+    klass2.expects(:my_class_method)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      klass1.my_class_method
+    }
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      klass2.my_class_method
+    }
+  end
+  
+  def test_should_allow_mocking_of_class_constructor
+    klass = MockClass.dup
+    expected_instance = Object.new
+    klass.expects(:new).returns(expected_instance)
+    assert_same expected_instance, klass.new
+  end
+  
+  def test_should_use_original_constructor_for_derived_classes
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class) { attr_reader :p1, :p2; def initialize(p1, p2); @p1, @p2 = p1, p2; end }
+    child_instance = child_class.new(1, 2)
+    assert_equal 1, child_instance.p1
+    assert_equal 2, child_instance.p2
+  end
+  
+  def test_should_not_expect_unexpected_parent_instance_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_instance = child_class.new
+    assert_raise(Test::Unit::AssertionFailedError) {
+      child_instance.unexpected_parent_instance_method
+    }    
+  end
+  
+  def test_should_expect_expected_parent_instance_method_call
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_instance = child_class.new
+    child_instance.expects(:expected_parent_instance_method)
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      child_instance.expected_parent_instance_method
+    }    
+  end
+  
+  def test_should_fail_verification_for_missing_parent_instance_method
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_instance = child_class.new
+    child_instance.expects(:expected_parent_instance_method)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      child_instance.verify
+    }
+  end
+  
+  def test_should_verify_expected_parent_class_method_call_from_child_class
+    parent_class = MockClass.dup
+    child_class = Class.new(parent_class)
+    child_instance = child_class.new
+    child_instance.expects(:expected_parent_instance_method)
+    child_instance.expected_parent_instance_method
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      child_instance.verify
+    }
+  end
+  
+end  

data/test/auto_mock_acceptance_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'mocha'
+require 'auto_mocha'
+
+class Product < ActiveRecord::Base
+   
+  def self.released_since(cutoff_date)
+    find(:all, :conditions => ['release_date > :date', {:date => cutoff_date}])
+  end
+  
+  def sales_with_price_exceeding(price_threshold)
+    sales.select { |sale| sale.price > price_threshold }
+  end
+  
+end
+
+class AutoMockAcceptanceTest < Test::Unit::TestCase
+  
+  def test_should_find_all_products_released_since_specified_date
+    new_releases = [Product.new]
+    Product.expects(:find).with(:all, :conditions => ['release_date > :date', {:date => :cutoff_date}]).returns(new_releases)
+    assert_equal new_releases, Product.released_since(:cutoff_date)
+  end
+  
+  def test_should_find_sales_for_this_product_which_exceeded_specified_price
+    product = Product.new
+    cheap_order = Mocha::Mock.new
+    cheap_order.expects(:price).returns(5)
+    expensive_order = Mocha::Mock.new
+    expensive_order.expects(:price).returns(15)
+    orders = [cheap_order, expensive_order]
+    product.expects(:sales).returns(orders)
+    assert_equal [expensive_order], product.sales_with_price_exceeding(10)
+  end
+  
+end

data/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/test/mocha/expectation_test.rb

@@ -0,0 +1,216 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+
+require 'mocha/expectation'
+
+class ExpectationTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_match_calls_to_same_method_with_any_parameters
+    expectation = Expectation.new(:expected_method)
+    assert expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_exactly_zero_parameters
+    expectation = Expectation.new(:expected_method).with()
+    assert expectation.match?(:expected_method)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_more_than_zero_parameters
+    expectation = Expectation.new(:expected_method).with()
+    assert !expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_expected_parameter_values
+    expectation = Expectation.new(:expected_method).with(1, 2, 3)
+    assert expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_parameters_constrained_as_expected
+    expectation = Expectation.new(:expected_method).with() {|x, y, z| x + y == z}
+    assert expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_not_match_calls_to_different_methods_with_no_parameters
+    expectation = Expectation.new(:expected_method)
+    assert !expectation.match?(:unexpected_method)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_too_few_parameters
+    expectation = Expectation.new(:expected_method).with(1, 2, 3)
+    assert !expectation.match?(:unexpected_method, 1, 2)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_too_many_parameters
+    expectation = Expectation.new(:expected_method).with(1, 2)
+    assert !expectation.match?(:unexpected_method, 1, 2, 3)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_unexpected_parameter_values
+    expectation = Expectation.new(:expected_method).with(1, 2, 3)
+    assert !expectation.match?(:unexpected_method, 1, 0, 3)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_parameters_not_constrained_as_expected
+    expectation = Expectation.new(:expected_method).with() {|x, y, z| x + y == z}
+    assert !expectation.match?(:expected_method, 1, 0, 3)
+  end
+  
+  def test_should_return_specified_value
+    expectation = Expectation.new(:expected_method).returns(99)
+    assert_equal 99, expectation.invoke
+  end
+  
+  def test_should_return_nil_if_no_value_specified
+    expectation = Expectation.new(:expected_method)
+    assert_nil expectation.invoke
+  end
+  
+  def test_should_return_evaluated_proc
+    expectation = Expectation.new(:expected_method).returns(lambda { 99 })
+    assert_equal 99, expectation.invoke
+  end
+  
+  def test_should_raise_runtime_exception
+    expectation = Expectation.new(:expected_method).raises
+    assert_raise(RuntimeError) { expectation.invoke }
+  end
+  
+  def test_should_raise_custom_exception
+    exception = Class.new(Exception)
+    expectation = Expectation.new(:expected_method).raises(exception)
+    assert_raise(exception) { expectation.invoke }
+  end
+  
+  def test_should_use_the_default_exception_message
+    expectation = Expectation.new(:expected_method).raises(Exception)
+    exception = assert_raise(Exception) { expectation.invoke }
+    assert_equal Exception.new.message, exception.message
+  end
+  
+  def test_should_raise_custom_exception_with_message
+    exception_msg = "exception message"
+    expectation = Expectation.new(:expected_method).raises(Exception, exception_msg)
+    exception = assert_raise(Exception) { expectation.invoke }
+    assert_equal exception_msg, exception.message
+  end
+  
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made
+    expectation = Expectation.new(:expected_method)
+    expectation.invoke
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made_at_least_once
+    expectation = Expectation.new(:expected_method).at_least_once
+    3.times {expectation.invoke}
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_not_made_at_least_once
+    expectation = Expectation.new(:expected_method).with(1, 2, 3).at_least_once
+    e = assert_raise(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+    assert_match(/expected calls: at least 1, actual calls: 0/i, e.message)
+  end
+  
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made_expected_number_of_times
+    expectation = Expectation.new(:expected_method).times(2)
+    2.times {expectation.invoke}
+    assert_nothing_raised(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_expect_call_not_to_be_made
+    expectation = Expectation.new(:expected_method)
+    expectation.define_instance_accessor(:how_many_times)
+    expectation.replace_instance_method(:times) { |how_many_times| self.how_many_times = how_many_times }
+    expectation.never
+    assert_equal 0, expectation.how_many_times
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_made_too_few_times
+    expectation = Expectation.new(:expected_method).times(2)
+    1.times {expectation.invoke}
+    e = assert_raise(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+    assert_match(/expected calls: 2, actual calls: 1/i, e.message)
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_made_too_many_times
+    expectation = Expectation.new(:expected_method).times(2)
+    3.times {expectation.invoke}
+    assert_raise(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_display_expectation_message_in_exception_message
+    options = [:a, :b, {:c => 1, :d => 2}]
+    expectation = Expectation.new(:expected_method).with(*options)
+    exception = assert_raise(Test::Unit::AssertionFailedError) {
+      expectation.verify
+    }
+    assert exception.message.include?(expectation.message)
+  end
+  
+  def test_should_combine_method_name_and_pretty_parameters
+    arguments = 1, 2, {'a' => true, :b => false}, [1, 2, 3]
+    expectation = Expectation.new(:meth).with(*arguments)
+    assert_equal ":meth(#{PrettyParameters.new(arguments).pretty})", expectation.message
+  end
+  
+  def test_should_not_include_parameters_in_message
+    expectation = Expectation.new(:meth)
+    assert_equal ":meth('** any **')", expectation.message
+  end
+  
+  def test_should_always_verify_successfully
+    stub = Stub.new(:meth)
+    assert stub.verify
+    stub.invoke
+    assert stub.verify
+  end
+  
+end
+
+class ExpectationSimilarExpectationsTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  attr_reader :expectation
+  def setup
+    @expectation = Expectation.new(:meth).with(2)
+  end
+  
+  def test_should_find_expectations_to_the_same_method
+    failed_expectation = MissingExpectation.new(:meth, [expectation]).with(1)
+    assert_equal [expectation], failed_expectation.similar_expectations
+  end
+  
+  def test_should_report_similar_expectations
+    missing_expectation = MissingExpectation.new(:meth, [expectation]).with(1)
+    exception = assert_raise(Test::Unit::AssertionFailedError) { missing_expectation.verify }
+    assert_equal "Unexpected message :meth(1)\nSimilar expectations :meth(2)", exception.message
+  end
+  
+  def test_should_ignore_expectations_to_different_methods
+    failed_expectation = MissingExpectation.new(:other_meth, [expectation]).with(1)
+    assert failed_expectation.similar_expectations.empty?
+  end
+  
+  def test_should_not_report_similar_expectations
+    missing_expectation = MissingExpectation.new(:other_meth, [expectation]).with(1)
+    exception = assert_raise(Test::Unit::AssertionFailedError) { missing_expectation.verify }
+    assert_equal "Unexpected message :other_meth(1)", exception.message
+  end
+  
+end