mocha 0.5.6 → 0.9.0

data/lib/mocha/stub.rb

@@ -1,18 +0,0 @@
-require 'mocha/expectation'
-
-module Mocha # :nodoc:
-
-  class Stub < Expectation # :nodoc:
-
-    def initialize(mock, method_name, backtrace = nil)
-      super
-      @expected_count = Range.at_least(0)
-    end
-    
-    def verify
-      true
-    end
-
-  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/unit/auto_verify_test.rb

@@ -1,129 +0,0 @@
-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
-      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.everything_stubbed
-  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)
-      class << mock
-        def verify(&block)
-          self.verify_called = true
-        end
-      end
-      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
-  
-  def test_should_build_sequence
-    assert_not_nil test_case.sequence('name')
-  end
-  
-end

data/test/unit/expectation_error_test.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/expectation_error'
-
-class ExpectationErrorTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = "/username/workspace/mocha_wibble/lib/"
-    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
-    expectation_error = ExpectationError.new(nil, backtrace, mocha_lib)
-    assert_equal ['/keep/me'], expectation_error.backtrace
-  end
-
-  def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new("/lib/$"), ExpectationError::LIB_DIRECTORY
-  end
-  
-  def test_should_set_error_message
-    expectation_error = ExpectationError.new('message')
-    assert_equal 'message', expectation_error.message
-  end
-
-end

data/test/unit/infinite_range_test.rb

@@ -1,53 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/infinite_range'
-require 'date'
-
-class InfiniteRangeTest < Test::Unit::TestCase
-  
-  def test_should_include_values_at_or_above_minimum
-    range = Range.at_least(10)
-    assert(range === 10)
-    assert(range === 11)
-    assert(range === 1000000)
-  end
-  
-  def test_should_not_include_values_below_minimum
-    range = Range.at_least(10)
-    assert_false(range === 0)
-    assert_false(range === 9)
-    assert_false(range === -11)
-  end
-  
-  def test_should_be_human_readable_description_for_at_least
-    assert_equal "at least 10", Range.at_least(10).mocha_inspect
-  end
-  
-  def test_should_include_values_at_or_below_maximum
-    range = Range.at_most(10)
-    assert(range === 10)
-    assert(range === 0)
-    assert(range === -1000000)
-  end
-  
-  def test_should_not_include_values_above_maximum
-    range = Range.at_most(10)
-    assert_false(range === 11)
-    assert_false(range === 1000000)
-  end
-  
-  def test_should_be_human_readable_description_for_at_most
-    assert_equal "at most 10", Range.at_most(10).mocha_inspect
-  end
-  
-  def test_should_be_same_as_standard_to_string
-    assert_equal((1..10).to_s, (1..10).mocha_inspect)
-    assert_equal((1...10).to_s, (1...10).mocha_inspect)
-    date_range = Range.new(Date.parse('2006-01-01'), Date.parse('2007-01-01'))
-    assert_equal date_range.to_s, date_range.mocha_inspect
-  end
-  
-  def assert_false(condition)
-    assert(!condition)
-  end
-  
-end

data/test/unit/missing_expectation_test.rb

@@ -1,42 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-
-require 'mocha/missing_expectation'
-require 'mocha/mock'
-
-class MissingExpectationTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_report_similar_expectations
-    mock = Mock.new
-    expectation_1 = mock.expects(:method_one).with(1)
-    expectation_2 = mock.expects(:method_one).with(1, 1)
-    expectation_3 = mock.expects(:method_two).with(2)
-
-    missing_expectation = MissingExpectation.new(mock, :method_one)
-    exception = assert_raise(ExpectationError) { missing_expectation.verify }
-    
-    expected_message = [
-      "#{missing_expectation.error_message(0, 1)}",
-      "Similar expectations:",
-      "#{expectation_1.method_signature}",
-      "#{expectation_2.method_signature}"
-    ].join("\n")
-    
-    assert_equal expected_message, exception.message
-  end
-  
-  def test_should_not_report_similar_expectations_if_there_are_none
-    mock = Mock.new
-    mock.expects(:method_two).with(2)
-    mock.expects(:method_two).with(2, 2)
-
-    missing_expectation = MissingExpectation.new(mock, :method_one)
-    exception = assert_raise(ExpectationError) { missing_expectation.verify }
-    
-    expected_message = "#{missing_expectation.error_message(0, 1)}"
-    
-    assert_equal expected_message, exception.message
-  end
-  
-end

data/test/unit/setup_and_teardown_test.rb

@@ -1,76 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/mock'
-
-require 'mocha/setup_and_teardown'
-
-class SetupAndTeardownTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_instantiate_new_stubba
-    test_case = stubbed_test_case_class.new
-    test_case.setup_stubs
-    
-    assert $stubba
-    assert $stubba.is_a?(Mocha::Central)
-  end
-
-  def test_should_verify_all_expectations
-    test_case = stubbed_test_case_class.new
-    stubba = Mock.new
-    stubba.expects(:verify_all)
-    $stubba = stubba
-    
-    test_case.verify_stubs
-    
-    stubba.verify
-  end
-
-  def test_should_yield_to_block_for_each_assertion
-    test_case = stubbed_test_case_class.new
-    $stubba = Mock.new
-    $stubba.stubs(:verify_all).yields
-    yielded = false
-    
-    test_case.verify_stubs { yielded = true }
-    
-    assert_equal true, yielded
-  end
-
-  def test_should_unstub_all_stubbed_methods
-    test_case = stubbed_test_case_class.new
-    stubba = Mock.new
-    stubba.expects(:unstub_all)
-    $stubba = stubba
-    
-    test_case.teardown_stubs
-    
-    stubba.verify
-  end
-
-  def test_should_set_stubba_to_nil
-    test_case = stubbed_test_case_class.new
-    $stubba = Mock.new
-    $stubba.stubs(:unstub_all)
-
-    test_case.teardown_stubs
-    
-    assert_nil $stubba
-  end
-  
-  def test_should_not_raise_exception_if_no_stubba_central_available
-    test_case = stubbed_test_case_class.new
-    $stubba = nil
-    assert_nothing_raised { test_case.teardown_stubs }
-  end
-  
-  private
-  
-  def stubbed_test_case_class
-    Class.new do
-      include Mocha::SetupAndTeardown
-    end
-  end
-
-end
-

data/test/unit/stub_test.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/stub'
-
-class StubTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_always_verify_successfully
-    stub = Stub.new(nil, :expected_method)
-    assert stub.verify
-    stub.invoke
-    assert stub.verify
-  end
-  
-  def test_should_match_successfully_for_any_number_of_invocations
-    stub = Stub.new(nil, :expected_method)
-    assert stub.match?(:expected_method)
-    stub.invoke
-    assert stub.match?(:expected_method)
-    stub.invoke
-    assert stub.match?(:expected_method)
-  end
-  
-end