mocha 0.5.6 → 3.0.2

data/test/acceptance/mocked_methods_dispatch_acceptance_test.rb

@@ -1,71 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class MockedMethodDispatchAcceptanceTest < Test::Unit::TestCase
-
-  include TestRunner
-
-  def test_should_find_latest_matching_expectation
-    test_result = run_test do
-      mock = mock()
-      mock.stubs(:method).returns(1)
-      mock.stubs(:method).returns(2)
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_find_latest_expectation_which_has_not_stopped_matching
-    test_result = run_test do
-      mock = mock()
-      mock.stubs(:method).returns(1)
-      mock.stubs(:method).once.returns(2)
-      assert_equal 2, mock.method
-      assert_equal 1, mock.method
-      assert_equal 1, mock.method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_keep_finding_later_stub_and_so_never_satisfy_earlier_expectation
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).returns(1)
-      mock.stubs(:method).returns(2)
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_find_later_expectation_until_it_stops_matching_then_find_earlier_stub
-    test_result = run_test do
-      mock = mock()
-      mock.stubs(:method).returns(1)
-      mock.expects(:method).returns(2)
-      assert_equal 2, mock.method
-      assert_equal 1, mock.method
-      assert_equal 1, mock.method
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_find_latest_expectation_with_range_of_expected_invocation_count_which_has_not_stopped_matching
-    test_result = run_test do
-      mock = mock()
-      mock.stubs(:method).returns(1)
-      mock.stubs(:method).times(2..3).returns(2)
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-      assert_equal 2, mock.method
-      assert_equal 1, mock.method
-      assert_equal 1, mock.method
-    end
-    assert_passed(test_result)
-  end
-
-end

data/test/acceptance/optional_parameters_acceptance_test.rb

@@ -1,63 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class OptionalParameterMatcherAcceptanceTest < Test::Unit::TestCase
-  
-  include TestRunner
-  
-  def test_should_pass_if_all_required_parameters_match_and_no_optional_parameters_are_supplied
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2)
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_pass_if_all_required_and_optional_parameters_match_and_some_optional_parameters_are_supplied
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2, 3)
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_pass_if_all_required_and_optional_parameters_match_and_all_optional_parameters_are_supplied
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2, 3, 4)
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_fail_if_all_required_and_optional_parameters_match_but_too_many_optional_parameters_are_supplied
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2, 3, 4, 5)
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_fail_if_all_required_parameters_match_but_some_optional_parameters_do_not_match
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2, 4)
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_fail_if_all_required_parameters_match_but_no_optional_parameters_match
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(1, 2, optionally(3, 4))
-      mock.method(1, 2, 4, 5)
-    end
-    assert_failed(test_result)
-  end
-
-end

data/test/acceptance/parameter_matcher_acceptance_test.rb

@@ -1,117 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class ParameterMatcherAcceptanceTest < Test::Unit::TestCase
-  
-  include TestRunner
-
-  def test_should_match_hash_parameter_with_specified_key
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_key(:key_1))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_hash_parameter_with_specified_key
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_key(:key_1))
-      mock.method(:key_2 => 'value_2')
-    end
-    assert_failed(test_result)
-  end
-  
-  def test_should_match_hash_parameter_with_specified_value
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_value('value_1'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_hash_parameter_with_specified_value
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_value('value_1'))
-      mock.method(:key_2 => 'value_2')
-    end
-    assert_failed(test_result)
-  end
-  
-  def test_should_match_hash_parameter_with_specified_key_value_pair
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entry(:key_1, 'value_1'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_hash_parameter_with_specified_key_value_pair
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entry(:key_1, 'value_2'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_failed(test_result)
-  end
-  
-  def test_should_match_hash_parameter_with_specified_hash_entry
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entry(:key_1 => 'value_1'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_hash_parameter_with_specified_hash_entry
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entry(:key_1 => 'value_2'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_failed(test_result)
-  end
-  
-  def test_should_match_hash_parameter_with_specified_entries
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entries(:key_1 => 'value_1', :key_2 => 'value_2'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_hash_parameter_with_specified_entries
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(has_entries(:key_1 => 'value_1', :key_2 => 'value_2'))
-      mock.method(:key_1 => 'value_1', :key_2 => 'value_3')
-    end
-    assert_failed(test_result)
-  end
-  
-  def test_should_match_parameter_that_matches_regular_expression
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(regexp_matches(/meter/))
-      mock.method('this parameter should match')
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_not_match_parameter_that_does_not_match_regular_expression
-    test_result = run_test do
-      mock = mock()
-      mock.expects(:method).with(regexp_matches(/something different/))
-      mock.method('this parameter should not match')
-    end
-    assert_failed(test_result)
-  end
-  
-end

data/test/acceptance/partial_mocks_acceptance_test.rb

@@ -1,40 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class PartialMockAcceptanceTest < Test::Unit::TestCase
-  
-  include TestRunner
-
-  def test_should_pass_if_all_expectations_are_satisfied
-    test_result = run_test do
-      partial_mock_one = "partial_mock_one"
-      partial_mock_two = "partial_mock_two"
-      
-      partial_mock_one.expects(:first)
-      partial_mock_one.expects(:second)
-      partial_mock_two.expects(:third)
-      
-      partial_mock_one.first
-      partial_mock_one.second
-      partial_mock_two.third
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_fail_if_all_expectations_are_not_satisfied
-    test_result = run_test do
-      partial_mock_one = "partial_mock_one"
-      partial_mock_two = "partial_mock_two"
-      
-      partial_mock_one.expects(:first)
-      partial_mock_one.expects(:second)
-      partial_mock_two.expects(:third)
-      
-      partial_mock_one.first
-      partial_mock_two.third
-    end
-    assert_failed(test_result)
-  end
-
-end

data/test/acceptance/sequence_acceptance_test.rb

@@ -1,179 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-require 'test_runner'
-
-class SequenceAcceptanceTest < Test::Unit::TestCase
-  
-  include TestRunner
-
-  def test_should_constrain_invocations_to_occur_in_expected_order
-    test_result = run_test do
-      mock = mock()
-      sequence = sequence('one')
-      
-      mock.expects(:first).in_sequence(sequence)
-      mock.expects(:second).in_sequence(sequence)
-      
-      mock.second
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_allow_invocations_in_sequence
-    test_result = run_test do
-      mock = mock()
-      sequence = sequence('one')
-      
-      mock.expects(:first).in_sequence(sequence)
-      mock.expects(:second).in_sequence(sequence)
-      
-      mock.first
-      mock.second
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_constrain_invocations_to_occur_in_expected_order_even_if_expected_on_different_mocks
-    test_result = run_test do
-      mock_one = mock('1')
-      mock_two = mock('2')
-      sequence = sequence('one')
-      
-      mock_one.expects(:first).in_sequence(sequence)
-      mock_two.expects(:second).in_sequence(sequence)
-      
-      mock_two.second
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_allow_invocations_in_sequence_even_if_expected_on_different_mocks
-    test_result = run_test do
-      mock_one = mock('1')
-      mock_two = mock('2')
-      sequence = sequence('one')
-      
-      mock_one.expects(:first).in_sequence(sequence)
-      mock_two.expects(:second).in_sequence(sequence)
-      
-      mock_one.first
-      mock_two.second
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_constrain_invocations_to_occur_in_expected_order_even_if_expected_on_partial_mocks
-    test_result = run_test do
-      partial_mock_one = "1"
-      partial_mock_two = "2"
-      sequence = sequence('one')
-      
-      partial_mock_one.expects(:first).in_sequence(sequence)
-      partial_mock_two.expects(:second).in_sequence(sequence)
-      
-      partial_mock_two.second
-    end
-    assert_failed(test_result)
-  end
-
-  def test_should_allow_invocations_in_sequence_even_if_expected_on_partial_mocks
-    test_result = run_test do
-      partial_mock_one = "1"
-      partial_mock_two = "2"
-      sequence = sequence('one')
-      
-      partial_mock_one.expects(:first).in_sequence(sequence)
-      partial_mock_two.expects(:second).in_sequence(sequence)
-      
-      partial_mock_one.first
-      partial_mock_two.second
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_allow_stub_expectations_to_be_skipped_in_sequence
-    test_result = run_test do
-      mock = mock()
-      sequence = sequence('one')
-      
-      mock.expects(:first).in_sequence(sequence)
-      s = mock.stubs(:second).in_sequence(sequence)
-      mock.expects(:third).in_sequence(sequence)
-      
-      mock.first
-      mock.third
-    end
-    assert_passed(test_result)
-  end
-
-  def test_should_regard_sequences_as_independent_of_each_other
-    test_result = run_test do
-      mock = mock()
-      sequence_one = sequence('one')
-      sequence_two = sequence('two')
-      
-      mock.expects(:first).in_sequence(sequence_one)
-      mock.expects(:second).in_sequence(sequence_one)
-      
-      mock.expects(:third).in_sequence(sequence_two)
-      mock.expects(:fourth).in_sequence(sequence_two)
-      
-      mock.first
-      mock.third
-      mock.second
-      mock.fourth
-    end
-    assert_passed(test_result)
-  end
-  
-  def test_should_include_sequence_in_failure_message
-    test_result = run_test do
-      mock = mock()
-      sequence = sequence('one')
-      
-      mock.expects(:first).in_sequence(sequence)
-      mock.expects(:second).in_sequence(sequence)
-      
-      mock.second
-    end
-    assert_failed(test_result)
-    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
-  end
-
-  def test_should_allow_expectations_to_be_in_more_than_one_sequence
-    test_result = run_test do
-      mock = mock()
-      sequence_one = sequence('one')
-      sequence_two = sequence('two')
-      
-      mock.expects(:first).in_sequence(sequence_one)
-      mock.expects(:second).in_sequence(sequence_two)
-      mock.expects(:three).in_sequence(sequence_one).in_sequence(sequence_two)
-      
-      mock.first
-      mock.three
-    end
-    assert_failed(test_result)
-    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
-    assert_match Regexp.new("in sequence 'two'"), test_result.failures.first.message
-  end
-
-  def test_should_have_shortcut_for_expectations_to_be_in_more_than_one_sequence
-    test_result = run_test do
-      mock = mock()
-      sequence_one = sequence('one')
-      sequence_two = sequence('two')
-      
-      mock.expects(:first).in_sequence(sequence_one)
-      mock.expects(:second).in_sequence(sequence_two)
-      mock.expects(:three).in_sequence(sequence_one, sequence_two)
-      
-      mock.first
-      mock.three
-    end
-    assert_failed(test_result)
-    assert_match Regexp.new("in sequence 'one'"), test_result.failures.first.message
-    assert_match Regexp.new("in sequence 'two'"), test_result.failures.first.message
-  end
-
-end

data/test/acceptance/standalone_acceptance_test.rb

@@ -1,131 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha_standalone'
-
-class NotATestUnitAssertionFailedError < StandardError
-end
-
-class NotATestUnitTestCase
-  
-  include Mocha::Standalone
-  
-  attr_reader :assertion_count
-  
-  def initialize
-    @assertion_count = 0
-  end
-  
-  def run(test_method)
-    mocha_setup
-    begin
-      prepare
-      begin
-        send(test_method)
-        mocha_verify { @assertion_count += 1 }
-      rescue Mocha::ExpectationError => e
-        new_error = NotATestUnitAssertionFailedError.new(e.message)
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      ensure
-        cleanup
-      end
-    ensure
-      mocha_teardown
-    end
-  end
-  
-  def prepare
-  end
-  
-  def cleanup
-  end
-    
-end
-
-class SampleTest < NotATestUnitTestCase
-  
-  def mocha_with_fulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-    mockee.blah
-  end
-  
-  def mocha_with_unfulfilled_expectation
-    mockee = mock()
-    mockee.expects(:blah)
-  end
-  
-  def mocha_with_unexpected_invocation
-    mockee = mock()
-    mockee.blah
-  end
-  
-  def stubba_with_fulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-    stubbee.blah
-  end
-  
-  def stubba_with_unfulfilled_expectation
-    stubbee = Class.new { define_method(:blah) {} }.new
-    stubbee.expects(:blah)
-  end
-  
-  def mocha_with_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wibble => 1)
-  end
-  
-  def mocha_with_non_matching_parameter
-    mockee = mock()
-    mockee.expects(:blah).with(has_key(:wibble))
-    mockee.blah(:wobble => 2)
-  end
-  
-end
-
-require 'test/unit'
-
-class StandaloneAcceptanceTest < Test::Unit::TestCase
-  
-  attr_reader :sample_test
-
-  def setup
-    @sample_test = SampleTest.new
-  end
-  
-  def test_should_pass_mocha_test
-    assert_nothing_raised { sample_test.run(:mocha_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_count
-  end
-
-  def test_should_fail_mocha_test_due_to_unfulfilled_exception
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_count
-  end
-
-  def test_should_fail_mocha_test_due_to_unexpected_invocation
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unexpected_invocation) }
-    assert_equal 0, sample_test.assertion_count
-  end
-
-  def test_should_pass_stubba_test
-    assert_nothing_raised { sample_test.run(:stubba_with_fulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_count
-  end
-
-  def test_should_fail_stubba_test
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:stubba_with_unfulfilled_expectation) }
-    assert_equal 1, sample_test.assertion_count
-  end
-
-  def test_should_pass_mocha_test_with_matching_parameter
-    assert_nothing_raised { sample_test.run(:mocha_with_matching_parameter) }
-    assert_equal 1, sample_test.assertion_count
-  end
-
-  def test_should_fail_mocha_test_with_non_matching_parameter
-    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_non_matching_parameter) }
-  end
-
-end

data/test/acceptance/stubba_acceptance_test.rb

@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha'
-
-class Widget
-  
-  def model
-    'original_model'
-  end
-    
-  class << self
-  
-    def find(options)
-      []
-    end
-  
-    def create(attributes)
-      Widget.new
-    end
-  
-  end
-  
-end
-
-module Thingy
-  
-  def self.wotsit
-    :hoojamaflip
-  end
-  
-end
-
-class StubbaAcceptanceTest < Test::Unit::TestCase
-  
-  def test_should_stub_instance_method
-    widget = Widget.new
-    widget.expects(:model).returns('different_model')
-    assert_equal 'different_model', widget.model
-  end
-  
-  def test_should_stub_module_method
-    should_stub_module_method
-  end
-  
-  def test_should_stub_module_method_again
-    should_stub_module_method
-  end
-  
-  def test_should_stub_class_method
-    should_stub_class_method
-  end
-  
-  def test_should_stub_class_method_again
-    should_stub_class_method
-  end
-  
-  def test_should_stub_instance_method_on_any_instance_of_a_class
-    should_stub_instance_method_on_any_instance_of_a_class
-  end
-  
-  def test_should_stub_instance_method_on_any_instance_of_a_class_again
-    should_stub_instance_method_on_any_instance_of_a_class
-  end
-  
-  def test_should_stub_two_different_class_methods
-    should_stub_two_different_class_methods
-  end
-  
-  def test_should_stub_two_different_class_methods_again
-    should_stub_two_different_class_methods
-  end
-  
-  private
-  
-  def should_stub_module_method
-    Thingy.expects(:wotsit).returns(:dooda)
-    assert_equal :dooda, Thingy.wotsit
-  end
-  
-  def should_stub_class_method
-    widgets = [Widget.new]
-    Widget.expects(:find).with(:all).returns(widgets)
-    assert_equal widgets, Widget.find(:all)
-  end 
-  
-  def should_stub_two_different_class_methods
-    found_widgets = [Widget.new]
-    created_widget = Widget.new
-    Widget.expects(:find).with(:all).returns(found_widgets)
-    Widget.expects(:create).with(:model => 'wombat').returns(created_widget)
-    assert_equal found_widgets, Widget.find(:all)
-    assert_equal created_widget, Widget.create(:model => 'wombat')
-  end
-  
-  def should_stub_instance_method_on_any_instance_of_a_class
-    Widget.any_instance.expects(:model).at_least_once.returns('another_model')
-    widget_1 = Widget.new
-    widget_2 = Widget.new
-    assert_equal 'another_model', widget_1.model
-    assert_equal 'another_model', widget_2.model
-  end
-
-end