mocha 0.3.1 → 0.3.2

data/test/auto_mocha/auto_mock_test.rb

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

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

@@ -1,35 +0,0 @@
-require 'test_helper'
-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