mocha 0.4.0 → 0.5.0

data/test/mocha/inspect_test.rb

@@ -1,90 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/inspect'
-require 'method_definer'
-
-class InspectTest
-  def self.suite
-    suite = Test::Unit::TestSuite.new('MochaInspectTests')
-    suite << ObjectInspectTest.suite
-    suite << TimeDateInspectTest.suite
-    suite << StringInspectTest.suite
-    suite << ArrayInstanceTest.suite
-    suite << HashInspectTest.suite
-    suite
-  end
-end
-
-class ObjectInspectTest < Test::Unit::TestCase
-  
-  def test_should_provide_custom_representation_of_object
-    object = Object.new
-    assert_equal "#<#{object.class}:#{"0x%x" % object.__id__}>", object.mocha_inspect
-  end
-  
-  def test_should_use_underscored_id_instead_of_object_id_or_id_so_that_they_can_be_stubbed
-    object = Object.new
-    object.define_instance_accessor(:called)
-    object.called = false
-    object.replace_instance_method(:object_id) { self.called = true; 1 }
-    object.replace_instance_method(:id) { self.called = true; 1 }
-    object.mocha_inspect
-    assert_equal false, object.called
-  end
-  
-end
-
-class TimeDateInspectTest < Test::Unit::TestCase
-  
-  def test_should_use_include_date_in_seconds
-    time = Time.now
-    assert_equal "#{time.inspect} (#{time.to_f} secs)", time.mocha_inspect
-  end
-  
-  def test_should_use_to_s_for_date
-    date = Date.new(2006, 1, 1)
-    assert_equal date.to_s, date.mocha_inspect
-  end
-  
-  def test_should_use_to_s_for_datetime
-    datetime = DateTime.new(2006, 1, 1)
-    assert_equal datetime.to_s, datetime.mocha_inspect
-  end
-  
-end
-
-class StringInspectTest < Test::Unit::TestCase
-  
-  def test_should_replace_escaped_quotes_with_single_quote
-    string = "my_string"
-    assert_equal "'my_string'", string.mocha_inspect
-  end
-  
-end
-
-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
-
-class HashInspectTest < Test::Unit::TestCase
-  
-  def test_should_keep_spacing_between_key_value
-    hash = {:a => true}
-    assert_equal '{:a => true}', hash.mocha_inspect
-  end
-  
-  def test_should_use_mocha_inspect_on_each_item
-    hash = {:a => 'mocha'}
-    assert_equal "{:a => 'mocha'}", hash.mocha_inspect
-  end
-  
-end

data/test/mocha/mock_methods_test.rb

@@ -1,235 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/mock_methods'
-require 'set'
-
-class MockMethodsTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_create_and_add_expectations
-    mock = Object.new
-    mock.extend(MockMethods)
-    
-    expectation1 = mock.expects(:method1)
-    expectation2 = mock.expects(:method2)
-    
-    assert_equal [expectation1, expectation2].to_set, mock.expectations.to_set
-  end
-  
-  def test_should_pass_backtrace_into_expectation
-    mock = Object.new
-    mock.extend(MockMethods)
-    backtrace = Object.new
-    expectation = mock.expects(:method1, backtrace)
-    assert_equal backtrace, expectation.backtrace
-  end
-  
-  def test_should_pass_backtrace_into_stub
-    mock = Object.new
-    mock.extend(MockMethods)
-    backtrace = Object.new
-    stub = mock.stubs(:method1, backtrace)
-    assert_equal backtrace, stub.backtrace
-  end
-  
-  def test_should_create_and_add_stubs
-    mock = Object.new
-    mock.extend(MockMethods)
-    
-    stub1 = mock.stubs(:method1)
-    stub2 = mock.stubs(:method2)
-    
-    assert_equal [stub1, stub2].to_set, mock.expectations.to_set
-  end
-  
-  def test_should_find_matching_expectation
-    mock = Object.new
-    mock.extend(MockMethods)
-
-    expectation1 = mock.expects(:my_method).with(:argument1, :argument2)
-    expectation2 = mock.expects(:my_method).with(:argument3, :argument4)
-    
-    assert_same expectation2, mock.matching_expectation(:my_method, :argument3, :argument4)
-  end
-  
-  def test_should_find_most_recent_matching_expectation
-    mock = Object.new
-    mock.extend(MockMethods)
-
-    expectation1 = mock.expects(:my_method).with(:argument1, :argument2)
-    expectation2 = mock.expects(:my_method).with(:argument1, :argument2)
-    
-    assert_same expectation2, mock.matching_expectation(:my_method, :argument1, :argument2)
-  end
-  
-  def test_should_invoke_expectation_and_return_result
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:my_method).returns(:result)
-    
-    result = mock.my_method
-    
-    assert_equal :result, result
-  end
-  
-  def test_should_not_raise_error_if_stubbing_everything
-    mock = Class.new { def initialize; @stub_everything = true; end }.new
-    mock.extend(MockMethods)
-    
-    result = nil
-    assert_nothing_raised(ExpectationError) do
-      result = mock.unexpected_method
-    end
-    assert_nil result
-  end
-  
-  def test_should_raise_no_method_error
-    mock = Object.new
-    mock.extend(MockMethods)
-    assert_raise(NoMethodError) do
-      mock.super_method_missing(nil)
-    end
-  end
-  
-  def test_should_raise_assertion_error_for_unexpected_method_call
-    mock = Object.new
-    mock.extend(MockMethods)
-    error = assert_raise(ExpectationError) do
-      mock.unexpected_method_called(:my_method, :argument1, :argument2)
-    end
-    assert_match /my_method/, error.message
-    assert_match /argument1/, error.message
-    assert_match /argument2/, error.message
-  end
-  
-  def test_should_indicate_unexpected_method_called
-    mock = Object.new
-    mock.extend(MockMethods)
-    class << mock
-      attr_accessor :symbol, :arguments
-      def unexpected_method_called(symbol, *arguments)
-        self.symbol, self.arguments = symbol, arguments
-      end
-    end
-    mock.my_method(:argument1, :argument2)
-
-    assert_equal :my_method, mock.symbol
-    assert_equal [:argument1, :argument2], mock.arguments
-  end
-  
-  def test_should_call_method_missing_for_parent
-    mock = Object.new
-    mock.extend(MockMethods)
-    class << mock
-      attr_accessor :symbol, :arguments
-      def super_method_missing(symbol, *arguments, &block)
-        self.symbol, self.arguments = symbol, arguments
-      end
-    end
-    
-    mock.my_method(:argument1, :argument2)
-    
-    assert_equal :my_method, mock.symbol
-    assert_equal [:argument1, :argument2], mock.arguments
-  end
-  
-  def test_should_verify_that_all_expectations_have_been_fulfilled
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:method1)
-    mock.expects(:method2)
-    mock.method1
-    assert_raise(ExpectationError) do
-      mock.verify
-    end
-  end
-  
-  def test_should_report_possible_expectations
-    mock = Object.new.extend(MockMethods)
-    mock.expects(:expected_method).with(1)
-    exception = assert_raise(ExpectationError) { mock.expected_method(2) }
-    assert_equal "#{mock.mocha_inspect}.expected_method(2) - expected calls: 0, actual calls: 1\nSimilar expectations:\nexpected_method(1)", exception.message
-  end
-  
-  def test_should_pass_block_through_to_expectations_verify_method
-    mock = Object.new
-    mock.extend(MockMethods)
-    expected_expectation = mock.expects(:method1)
-    mock.method1
-    expectations = []
-    mock.verify() { |expectation| expectations << expectation }
-    assert_equal [expected_expectation], expectations
-  end
-  
-  def test_should_yield_supplied_parameters_to_block
-    mock = Object.new
-    mock.extend(MockMethods)
-    parameters_for_yield = [1, 2, 3]
-    mock.expects(:method1).yields(*parameters_for_yield)
-    yielded_parameters = nil
-    mock.method1() { |*parameters| yielded_parameters = parameters }
-    assert_equal parameters_for_yield, yielded_parameters
-  end
-  
-  def test_should_respond_to_expected_method
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?(:method1)
-  end
-  
-  def test_should_not_respond_to_unexpected_method
-    mock = Object.new
-    mock.extend(MockMethods)
-    assert_equal false, mock.respond_to?(:method1)
-  end
-  
-  def test_should_set_up_multiple_expectations_with_return_values
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-  
-  def test_should_set_up_multiple_stubs_with_return_values
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.stubs(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-  
-  def test_should_match_most_recent_call_to_expects
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_stubs
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.stubs(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_call_to_expects_with_previous_call_to_stubs
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.stubs(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_call_to_stubs_with_previous_call_to_expects
-    mock = Object.new
-    mock.extend(MockMethods)
-    mock.expects(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-end

data/test/mocha/mock_test.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/mock'
-require 'mocha/expectation_error'
-
-class MockTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_include_mocha_methods
-   assert Mock.included_modules.include?(MockMethods)
-  end
-
-  def test_should_set_single_expectation
-   mock = Mock.new
-   mock.expects(:method1).returns(1)
-   assert_nothing_raised(ExpectationError) do
-     assert_equal 1, mock.method1
-   end
-  end 
-
-  def test_should_build_and_store_expectations
-   mock = Mock.new
-   expectation = mock.expects(:method1)
-   assert_not_nil expectation
-   assert_equal [expectation], mock.expectations
-  end
-  
-  def test_should_not_stub_everything_by_default
-    mock = Mock.new
-    assert_equal false, mock.stub_everything
-  end
-  
-  def test_should_stub_everything
-    mock = Mock.new(stub_everything = true)
-    assert_equal true, mock.stub_everything
-  end
-  
-  def test_should_display_object_id_for_inspect_if_mock_has_no_name
-    mock = Mock.new
-    assert_match Regexp.new("#<Mock:0x[0-9A-Fa-f]{6}>"), mock.mocha_inspect
-  end
-  
-  def test_should_display_name_for_inspect_if_mock_has_name
-    mock = Mock.new(false, 'named_mock')
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
-  end
-
-  def test_should_give_name_in_inspect_message
-    mock = Mock.new(false, 'named_mock')
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
-  end
-  
-  def test_should_be_able_to_extend_mock_object_with_module
-    mock = Mock.new
-    assert_nothing_raised(ExpectationError) { mock.extend(Module.new) }
-  end
-  
-  def test_should_be_equal
-    mock = Mock.new
-    assert_equal true, mock.eql?(mock)
-  end
-    
-  def test_should_be_able_to_mock_standard_object_methods
-    mock = Mock.new
-    object_methods = Object.public_instance_methods.reject { |m| m =~ /^__.*__$/ }.sort
-    object_methods.each { |method| mock.__expects__(method.to_sym).returns(method) }
-    object_methods.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-    assert_nothing_raised(ExpectationError) { mock.verify }
-  end
-
-  def test_should_be_able_to_stub_standard_object_methods
-    mock = Mock.new
-    object_methods = Object.public_instance_methods.reject { |m| m =~ /^__.*__$/ }.sort
-    object_methods.each { |method| mock.__stubs__(method.to_sym).returns(method) }
-    object_methods.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-  end
-  
-  def test_should_respond_to_expected_methods
-    mock = Mock.new
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?(:method1)
-  end
-  
-end