redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/test/acceptance/expected_invocation_count_acceptance_test.rb

@@ -0,0 +1,187 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+require 'test_runner'
+
+class ExpectedInvocationCountAcceptanceTest < Test::Unit::TestCase
+
+  include TestRunner
+
+  def test_should_pass_if_method_is_never_expected_and_is_never_called
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).never
+      0.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_fail_if_method_is_never_expected_but_is_called_once
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).never
+      1.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: 0, actual calls: 1'], failure_messages
+  end
+  
+  def test_should_pass_if_method_is_expected_twice_and_is_called_twice
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2)
+      2.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_fail_if_method_is_expected_twice_but_is_called_once
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2)
+      1.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: 2, actual calls: 1'], failure_messages
+  end
+  
+  def test_should_fail_if_method_is_expected_twice_but_is_called_three_times
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2)
+      3.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: 2, actual calls: 3'], failure_messages
+  end
+  
+  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_twice
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2..4)
+      2.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_three_times
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2..4)
+      3.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_pass_if_method_is_expected_between_two_and_four_times_and_is_called_four_times
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2..4)
+      4.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+
+  def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_once
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2..4)
+      1.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: 2..4, actual calls: 1'], failure_messages
+  end
+
+  def test_should_fail_if_method_is_expected_between_two_and_four_times_and_is_called_five_times
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).times(2..4)
+      5.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: 2..4, actual calls: 5'], failure_messages
+  end
+  
+  def test_should_pass_if_method_is_expected_at_least_once_and_is_called_once
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_least_once
+      1.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_pass_if_method_is_expected_at_least_once_and_is_called_twice
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_least_once
+      2.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_fail_if_method_is_expected_at_least_once_but_is_never_called
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_least_once
+      0.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: at least 1, actual calls: 0'], failure_messages
+  end
+  
+  def test_should_pass_if_method_is_expected_at_most_once_and_is_never_called
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_most_once
+      0.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_pass_if_method_is_expected_at_most_once_and_called_once
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_most_once
+      1.times { mock.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_fail_if_method_is_expected_at_most_once_but_is_called_twice
+    test_result = run_test do
+      mock = mock('mock')
+      mock.expects(:method).at_most_once
+      2.times { mock.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:mock>.method - expected calls: at most 1, actual calls: 2'], failure_messages
+  end
+  
+  def test_should_pass_if_method_is_never_expected_and_is_never_called_even_if_everything_is_stubbed
+    test_result = run_test do
+      stub = stub_everything('stub')
+      stub.expects(:method).never
+      0.times { stub.method }
+    end
+    assert_passed(test_result)
+  end
+  
+  def test_should_fail_if_method_is_never_expected_but_is_called_once_even_if_everything_is_stubbed
+    test_result = run_test do
+      stub = stub_everything('stub')
+      stub.expects(:method).never
+      1.times { stub.method }
+    end
+    assert_failed(test_result)
+    failure_messages = test_result.failures.map { |failure| failure.message }
+    assert_equal ['#<Mock:stub>.method - expected calls: 0, actual calls: 1'], failure_messages
+  end
+  
+end

data/lib/openssl/mocha/test/acceptance/mocha_acceptance_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha'
+
+class MochaAcceptanceTest < Test::Unit::TestCase
+  
+  class Rover
+
+    def initialize(left_track, right_track, steps_per_metre, steps_per_degree)
+      @left_track, @right_track, @steps_per_metre, @steps_per_degree = left_track, right_track, steps_per_metre, steps_per_degree
+    end
+
+    def forward(metres)
+      @left_track.step(metres * @steps_per_metre)
+      @right_track.step(metres * @steps_per_metre)
+      wait
+    end
+
+    def backward(metres)
+      forward(-metres)
+    end
+    
+    def left(degrees)
+      @left_track.step(-degrees * @steps_per_degree)
+      @right_track.step(+degrees * @steps_per_degree)
+      wait
+    end
+    
+    def right(degrees)
+      left(-degrees)
+    end
+    
+    def wait
+      while (@left_track.moving? or @right_track.moving?); end
+    end
+
+  end
+  
+  def test_should_step_both_tracks_forward_ten_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:step).with(10)
+    right_track.expects(:step).with(10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.forward(2)
+  end
+  
+  def test_should_step_both_tracks_backward_ten_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:step).with(-10)
+    right_track.expects(:step).with(-10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.backward(2)
+  end
+  
+  def test_should_step_left_track_forwards_five_steps_and_right_track_backwards_five_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:step).with(+5)
+    right_track.expects(:step).with(-5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.right(90)
+  end
+  
+  def test_should_step_left_track_backwards_five_steps_and_right_track_forwards_five_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:step).with(-5)
+    right_track.expects(:step).with(+5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.left(90)
+  end
+  
+end

data/lib/openssl/mocha/test/acceptance/mocked_methods_dispatch_acceptance_test.rb

@@ -0,0 +1,71 @@
+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/lib/openssl/mocha/test/acceptance/parameter_matcher_acceptance_test.rb

@@ -0,0 +1,63 @@
+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_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_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
+  
+end

data/lib/openssl/mocha/test/acceptance/standalone_acceptance_test.rb

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