jferris-mocha 0.9.5.0.1240002286

data/test/unit/parameters_matcher_test.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/parameters_matcher'
+
+class ParametersMatcherTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_match_any_actual_parameters_if_no_expected_parameters_specified
+    parameters_matcher = ParametersMatcher.new
+    assert parameters_matcher.match?(actual_parameters = [1, 2, 3])
+  end
+
+  def test_should_match_if_actual_parameters_are_same_as_expected_parameters
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, 6])
+    assert parameters_matcher.match?(actual_parameters = [4, 5, 6])
+  end
+  
+  def test_should_not_match_if_actual_parameters_are_different_from_expected_parameters
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, 6])
+    assert !parameters_matcher.match?(actual_parameters = [1, 2, 3])
+  end
+  
+  def test_should_not_match_if_there_are_less_actual_parameters_than_expected_parameters
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, 6])
+    assert !parameters_matcher.match?(actual_parameters = [4, 5])
+  end
+  
+  def test_should_not_match_if_there_are_more_actual_parameters_than_expected_parameters
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5])
+    assert !parameters_matcher.match?(actual_parameters = [4, 5, 6])
+  end
+  
+  def test_should_not_match_if_not_all_required_parameters_are_supplied
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert !parameters_matcher.match?(actual_parameters = [4])
+  end
+  
+  def test_should_match_if_all_required_parameters_match_and_no_optional_parameters_are_supplied
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert parameters_matcher.match?(actual_parameters = [4, 5])
+  end
+  
+  def test_should_match_if_all_required_and_optional_parameters_match_and_some_optional_parameters_are_supplied
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert parameters_matcher.match?(actual_parameters = [4, 5, 6])
+  end
+  
+  def test_should_match_if_all_required_and_optional_parameters_match_and_all_optional_parameters_are_supplied
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert parameters_matcher.match?(actual_parameters = [4, 5, 6, 7])
+  end
+  
+  def test_should_not_match_if_all_required_and_optional_parameters_match_but_too_many_optional_parameters_are_supplied
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert !parameters_matcher.match?(actual_parameters = [4, 5, 6, 7, 8])
+  end
+  
+  def test_should_not_match_if_all_required_parameters_match_but_some_optional_parameters_do_not_match
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert !parameters_matcher.match?(actual_parameters = [4, 5, 6, 0])
+  end
+
+  def test_should_not_match_if_some_required_parameters_do_not_match_although_all_optional_parameters_do_match
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert !parameters_matcher.match?(actual_parameters = [4, 0, 6])
+  end
+
+  def test_should_not_match_if_all_required_parameters_match_but_no_optional_parameters_match
+    optionals = ParameterMatchers::Optionally.new(6, 7)
+    parameters_matcher = ParametersMatcher.new(expected_parameters = [4, 5, optionals])
+    assert !parameters_matcher.match?(actual_parameters = [4, 5, 0, 0])
+  end
+
+  def test_should_match_if_actual_parameters_satisfy_matching_block
+    parameters_matcher = ParametersMatcher.new { |x, y| x + y == 3 }
+    assert parameters_matcher.match?(actual_parameters = [1, 2])
+  end
+
+  def test_should_not_match_if_actual_parameters_do_not_satisfy_matching_block
+    parameters_matcher = ParametersMatcher.new { |x, y| x + y == 3 }
+    assert !parameters_matcher.match?(actual_parameters = [2, 3])
+  end
+  
+  def test_should_remove_outer_array_braces
+    params = [1, 2, [3, 4]]
+    parameters_matcher = ParametersMatcher.new(params)
+    assert_equal '(1, 2, [3, 4])', parameters_matcher.mocha_inspect
+  end
+  
+  def test_should_display_numeric_arguments_as_is
+    params = [1, 2, 3]
+    parameters_matcher = ParametersMatcher.new(params)
+    assert_equal '(1, 2, 3)', parameters_matcher.mocha_inspect
+  end
+  
+  def test_should_remove_curly_braces_if_hash_is_only_argument
+    params = [{:a => 1, :z => 2}]
+    parameters_matcher = ParametersMatcher.new(params)
+    assert_nil parameters_matcher.mocha_inspect.index('{')
+    assert_nil parameters_matcher.mocha_inspect.index('}')
+  end
+  
+  def test_should_not_remove_curly_braces_if_hash_is_not_the_only_argument
+    params = [1, {:a => 1}]
+    parameters_matcher = ParametersMatcher.new(params)
+    assert_equal '(1, {:a => 1})', parameters_matcher.mocha_inspect
+  end
+  
+  def test_should_indicate_that_matcher_will_match_any_actual_parameters
+    parameters_matcher = ParametersMatcher.new
+    assert_equal '(any_parameters)', parameters_matcher.mocha_inspect
+  end
+
+end

data/test/unit/return_values_test.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/return_values'
+
+class ReturnValuesTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_return_nil
+    values = ReturnValues.new
+    assert_nil values.next
+  end
+
+  def test_should_keep_returning_nil
+    values = ReturnValues.new
+    values.next
+    assert_nil values.next
+    assert_nil values.next
+  end
+
+  def test_should_return_evaluated_single_return_value
+    values = ReturnValues.new(SingleReturnValue.new('value'))
+    assert_equal 'value', values.next
+  end
+
+  def test_should_keep_returning_evaluated_single_return_value
+    values = ReturnValues.new(SingleReturnValue.new('value'))
+    values.next
+    assert_equal 'value', values.next
+    assert_equal 'value', values.next
+  end
+
+  def test_should_return_consecutive_evaluated_single_return_values
+    values = ReturnValues.new(SingleReturnValue.new('value_1'), SingleReturnValue.new('value_2'))
+    assert_equal 'value_1', values.next
+    assert_equal 'value_2', values.next
+  end
+
+  def test_should_keep_returning_last_of_consecutive_evaluated_single_return_values
+    values = ReturnValues.new(SingleReturnValue.new('value_1'), SingleReturnValue.new('value_2'))
+    values.next
+    values.next
+    assert_equal 'value_2', values.next
+    assert_equal 'value_2', values.next
+  end
+  
+  def test_should_build_single_return_values_for_each_values
+    values = ReturnValues.build('value_1', 'value_2', 'value_3').values
+    assert_equal 'value_1', values[0].evaluate
+    assert_equal 'value_2', values[1].evaluate
+    assert_equal 'value_3', values[2].evaluate
+  end
+  
+  def test_should_combine_two_sets_of_return_values
+    values_1 = ReturnValues.build('value_1')
+    values_2 = ReturnValues.build('value_2a', 'value_2b')
+    values = (values_1 + values_2).values
+    assert_equal 'value_1', values[0].evaluate
+    assert_equal 'value_2a', values[1].evaluate
+    assert_equal 'value_2b', values[2].evaluate
+  end
+
+end

data/test/unit/sequence_test.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/sequence'
+require 'mocha/expectation'
+
+class SequenceTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  class FakeExpectation
+    
+    attr_reader :ordering_constraints
+    
+    def initialize(satisfied = false)
+      @satisfied = satisfied
+      @ordering_constraints = []
+    end
+    
+    def add_ordering_constraint(ordering_constraint)
+      @ordering_constraints << ordering_constraint
+    end
+    
+    def satisfied?
+      @satisfied
+    end
+    
+  end
+  
+  def test_should_be_satisfied_if_no_expectations_added
+    sequence = Sequence.new('name')
+    assert sequence.satisfied_to_index?(0)
+  end
+
+  def test_should_be_satisfied_if_one_unsatisfied_expectations_added_but_it_is_not_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert sequence.satisfied_to_index?(0)
+  end
+
+  def test_should_not_be_satisfied_if_one_unsatisfied_expectations_added_and_it_is_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert !sequence.satisfied_to_index?(1)
+  end
+
+  def test_should_be_satisfied_if_one_satisfied_expectations_added_and_it_is_included_by_index
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new(satisfied = true)
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert sequence.satisfied_to_index?(1)
+  end
+
+  def test_should_not_be_satisfied_if_one_satisfied_and_one_unsatisfied_expectation_added_and_both_are_included_by_index
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert !sequence.satisfied_to_index?(2)
+  end
+
+  def test_should_be_satisfied_if_two_satisfied_expectations_added_and_both_are_included_by_index
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = true)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert sequence.satisfied_to_index?(2)
+  end
+  
+  def test_should_add_ordering_constraint_to_expectation
+    sequence = Sequence.new('name')
+    expectation = FakeExpectation.new
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert_equal 1, expectation.ordering_constraints.length
+  end
+
+  def test_should_not_allow_invocation_of_second_method_when_first_n_sequence_has_not_been_invoked
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = false)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert !expectation_two.ordering_constraints[0].allows_invocation_now?
+  end
+
+  def test_should_allow_invocation_of_second_method_when_first_in_sequence_has_been_invoked
+    sequence = Sequence.new('name')
+    expectation_one = FakeExpectation.new(satisfied = true)
+    expectation_two = FakeExpectation.new(satisfied = false)
+    sequence.constrain_as_next_in_sequence(expectation_one)
+    sequence.constrain_as_next_in_sequence(expectation_two)
+    assert expectation_two.ordering_constraints[0].allows_invocation_now?
+  end
+
+  def test_should_describe_ordering_constraint_as_being_part_of_named_sequence
+    sequence = Sequence.new('wibble')
+    expectation = FakeExpectation.new
+    sequence.constrain_as_next_in_sequence(expectation)
+    assert_equal "in sequence 'wibble'", expectation.ordering_constraints[0].mocha_inspect
+  end
+
+end

data/test/unit/single_return_value_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/single_return_value'
+
+class SingleReturnValueTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_return_value
+    value = SingleReturnValue.new('value')
+    assert_equal 'value', value.evaluate
+  end
+  
+end

data/test/unit/single_yield_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/single_yield'
+
+class SingleYieldTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_provide_parameters_for_single_yield_in_single_invocation
+    parameter_group = SingleYield.new(1, 2, 3)
+    parameter_groups = []
+    parameter_group.each do |parameters|
+      parameter_groups << parameters
+    end
+    assert_equal [[1, 2, 3]], parameter_groups
+  end
+  
+end

data/test/unit/state_machine_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/state_machine'
+
+class StateMachineTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_initially_be_in_no_state
+    state_machine = StateMachine.new('name')
+    any_state.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_able_to_enter_a_state
+    state_machine = StateMachine.new('name')
+    state = 'A'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_able_to_change_state
+    state_machine = StateMachine.new('name')
+    state = 'B'
+    other_states = any_state.reject { |s| s == state }
+    
+    state_machine.is('A').activate
+    state_machine.is(state).activate
+    
+    assert state_machine.is(state).active?
+    assert !state_machine.is_not(state).active?
+    other_states.each do |s|
+      assert !state_machine.is(s).active?
+      assert state_machine.is_not(s).active?
+    end
+  end
+  
+  def test_should_be_put_into_an_initial_state
+    state_machine = StateMachine.new('name')
+    initial_state = 'A'
+    other_states = any_state.reject { |s| s == initial_state }
+    
+    state_machine.starts_as(initial_state)
+    
+    assert state_machine.is(initial_state).active?
+    assert !state_machine.is_not(initial_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_be_put_into_a_new_state
+    next_state = 'B'
+    
+    other_states = any_state.reject { |s| s == next_state }
+    state_machine = StateMachine.new('name').starts_as('A')
+    
+    state_machine.become(next_state)
+    
+    assert state_machine.is(next_state).active?
+    assert !state_machine.is_not(next_state).active?
+    other_states.each do |state|
+      assert !state_machine.is(state).active?
+      assert state_machine.is_not(state).active?
+    end
+  end
+  
+  def test_should_describe_itself_as_name_and_current_state
+    state_machine = StateMachine.new('state_machine_name')
+    assert_equal 'state_machine_name has no current state', state_machine.mocha_inspect
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    state_machine.is(inspectable_state).activate
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.mocha_inspect
+  end
+  
+  def test_should_have_self_describing_states
+    state_machine = StateMachine.new('state_machine_name')
+    inspectable_state = Class.new { define_method(:mocha_inspect) { "'inspectable_state'" } }.new
+    assert_equal "state_machine_name is 'inspectable_state'", state_machine.is(inspectable_state).mocha_inspect
+    assert_equal "state_machine_name is not 'inspectable_state'", state_machine.is_not(inspectable_state).mocha_inspect
+  end
+  
+  def any_state
+    %w(A B C D)
+  end
+  
+end

data/test/unit/string_inspect_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+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

data/test/unit/yield_parameters_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/yield_parameters'
+require 'mocha/no_yields'
+require 'mocha/single_yield'
+require 'mocha/multiple_yields'
+
+class YieldParametersTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_return_null_yield_parameter_group_by_default
+    yield_parameters = YieldParameters.new
+    assert yield_parameters.next_invocation.is_a?(NoYields)
+  end
+  
+  def test_should_return_single_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+  end
+  
+  def test_should_keep_returning_single_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.next_invocation
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+  end
+  
+  def test_should_return_consecutive_single_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.add(4, 5)
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [4, 5], parameter_group.parameters
+  end
+  
+  def test_should_return_multiple_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+  end
+  
+  def test_should_keep_returning_multiple_yield_parameter_group
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    yield_parameters.next_invocation
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+  end
+  
+  def test_should_return_consecutive_multiple_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.multiple_add([1, 2, 3], [4, 5])
+    yield_parameters.multiple_add([6, 7], [8, 9, 0])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[6, 7], [8, 9, 0]], parameter_group.parameter_groups
+  end
+  
+  def test_should_return_consecutive_single_and_multiple_yield_parameter_groups
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, 2, 3)
+    yield_parameters.multiple_add([4, 5, 6], [7, 8])
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(SingleYield)
+    assert_equal [1, 2, 3], parameter_group.parameters
+    parameter_group = yield_parameters.next_invocation
+    assert parameter_group.is_a?(MultipleYields)
+    assert_equal [[4, 5, 6], [7, 8]], parameter_group.parameter_groups
+  end
+  
+end