mocha 0.1

data/test/mocha/infinite_range_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/infinite_range'
+
+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).to_s
+  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).to_s
+  end
+  
+  def test_should_not_break_original_description
+    assert_equal "1..10", (1..10).to_s
+    assert_equal "1...10", (1...10).to_s
+  end
+  
+  def assert_false(condition)
+    assert(!condition)
+  end
+  
+end

data/test/mocha/inspect_test.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+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}: #{object.object_id}>", object.mocha_inspect
+  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

@@ -0,0 +1,141 @@
+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_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_equal expectation2, mock.matching_expectation(:my_method, :argument3, :argument4)
+  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_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(Test::Unit::AssertionFailedError) 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(Test::Unit::AssertionFailedError) do
+      mock.verify
+    end
+  end
+  
+  def test_should_only_verify_expectations_matching_method_name
+    mock = Object.new
+    mock.extend(MockMethods)
+    mock.expects(:method1)
+    mock.expects(:method2)
+    mock.method1
+    assert_nothing_raised(Test::Unit::AssertionFailedError) do
+      mock.verify(:method1)
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      mock.verify(:method2)
+    end
+  end
+  
+  def test_should_only_verify_expectations_matching_multiple_method_names
+    mock = Object.new
+    mock.extend(MockMethods)
+    mock.expects(:method1)
+    mock.expects(:method2)
+    assert_raise(Test::Unit::AssertionFailedError) do
+      mock.verify(:method1, :method2)
+    end
+  end
+  
+  def test_should_report_possible_expectations
+    mock = Object.new.extend(MockMethods)
+    mock.expects(:meth).with(1)
+    exception = assert_raise(Test::Unit::AssertionFailedError) { mock.meth(2) }
+    assert_equal "Unexpected message :meth(2)\nSimilar expectations :meth(1)", exception.message
+  end
+  
+end

data/test/mocha/mock_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mock'
+
+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(Test::Unit::AssertionFailedError) do
+     assert_equal 1, mock.method1
+   end
+  end 
+
+  def test_should_set_multiple_expectations_in_constructor
+   mock = Mock.new(:method1 => 1, :method2 => 2)
+   assert_nothing_raised(Test::Unit::AssertionFailedError) do
+     assert_equal 1, mock.method1
+     assert_equal 2, mock.method2
+   end
+  end 
+
+  def test_should_claim_to_respond_to_any_method
+   mock = Mock.new
+   always_responds = mock.always_responds
+   assert always_responds.respond_to?(:gobble_de_gook)
+  end
+
+  def test_should_raise_exception_if_attempting_to_mock_undefined_method
+   mocked = Class.new
+   mock = Mock.new(mocked.new)
+   assert_raise(Test::Unit::AssertionFailedError) do
+     mock.expects(:method1)
+   end
+  end
+
+  def test_should_not_raise_exception_if_attempting_to_mock_defined_method
+   mocked = Class.new { def method1; end }
+   mock = Mock.new(mocked.new)
+   assert_nothing_raised(Test::Unit::AssertionFailedError) do
+     mock.expects(:method1)
+   end
+  end
+
+  def test_should_not_raise_exception_if_attempting_to_mock_method_when_no_class_specified
+   mock = Mock.new
+   assert_nothing_raised(Test::Unit::AssertionFailedError) do
+     mock.expects(: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
+   
+end

data/test/mocha/pretty_parameters_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/pretty_parameters'
+
+class PrettyParametersTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_remove_outer_array_braces
+    params = [1, 2, [3, 4]]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, 2, [3, 4]', parameters.pretty
+  end
+  
+  def test_should_display_numeric_arguments_as_is
+    params = [1, 2, 3]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, 2, 3', parameters.pretty
+  end
+  
+  def test_should_remove_curly_braces_if_hash_is_only_argument
+    params = [{:a => 1, :z => 2}]
+    parameters = PrettyParameters.new(params)
+    assert_match /^:[az] => [12], :[az] => [12]$/, parameters.pretty
+  end
+  
+  def test_should_not_remove_curly_braces_if_hash_is_not_the_only_argument
+    params = [1, {:a => 1}]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, {:a => 1}', parameters.pretty
+  end
+
+end

data/test/mocha_acceptance_test.rb

@@ -0,0 +1,112 @@
+require '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.move(metres * @steps_per_metre)
+      @right_track.move(metres * @steps_per_metre)
+      wait
+    end
+
+    def backward(metres)
+      forward(-metres)
+    end
+    
+    def left(degrees)
+      @left_track.move(-degrees * @steps_per_degree)
+      @right_track.move(+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
+  
+  include Mocha
+
+  def test_should_move_both_tracks_forward_ten_steps
+    left_track = Mock.new
+    right_track = Mock.new
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:move).with(10)
+    right_track.expects(:move).with(10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.forward(2)
+    
+    left_track.verify
+    right_track.verify
+  end
+  
+  def test_should_move_both_tracks_backward_ten_steps
+    left_track = Mock.new
+    right_track = Mock.new
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:move).with(-10)
+    right_track.expects(:move).with(-10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.backward(2)
+    
+    left_track.verify
+    right_track.verify
+  end
+  
+  def test_should_move_left_track_forwards_five_steps_and_right_track_backwards_five_steps
+    left_track = Mock.new
+    right_track = Mock.new
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:move).with(+5)
+    right_track.expects(:move).with(-5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.right(90)
+    
+    left_track.verify
+    right_track.verify
+  end
+  
+  def test_should_move_left_track_backwards_five_steps_and_right_track_forwards_five_steps
+    left_track = Mock.new
+    right_track = Mock.new
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:move).with(-5)
+    right_track.expects(:move).with(+5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.left(90)
+    
+    left_track.verify
+    right_track.verify
+  end
+  
+end