mocha 1.10.1 → 1.12.0

data/test/unit/sequence_test.rb

@@ -1,100 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/sequence'
-require 'mocha/expectation'
-
-class SequenceTest < Mocha::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(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(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(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(true)
-    expectation_two = FakeExpectation.new(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(true)
-    expectation_two = FakeExpectation.new(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(false)
-    expectation_two = FakeExpectation.new(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(true)
-    expectation_two = FakeExpectation.new(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

@@ -1,17 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/invocation'
-require 'mocha/single_return_value'
-
-class SingleReturnValueTest < Mocha::TestCase
-  include Mocha
-
-  def new_invocation
-    Invocation.new(:irrelevant, :irrelevant)
-  end
-
-  def test_should_return_value
-    value = SingleReturnValue.new('value')
-    assert_equal 'value', value.evaluate(new_invocation)
-  end
-end

data/test/unit/single_yield_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/single_yield'
-
-class SingleYieldTest < Mocha::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

@@ -1,96 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/state_machine'
-
-class StateMachineTest < Mocha::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

@@ -1,9 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class StringInspectTest < Mocha::TestCase
-  def test_should_use_default_inspect_method
-    string = 'my_string'
-    assert_equal %("my_string"), string.mocha_inspect
-  end
-end

data/test/unit/thrower_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/invocation'
-require 'mocha/thrower'
-
-class ThrowerTest < Mocha::TestCase
-  include Mocha
-
-  def new_invocation
-    Invocation.new(:irrelevant, :irrelevant)
-  end
-
-  def test_should_throw_tag
-    thrower = Thrower.new(:tag)
-    assert_throws(:tag) { thrower.evaluate(new_invocation) }
-  end
-
-  def test_should_throw_tag_with_return_value
-    thrower = Thrower.new(:tag, 'return-value')
-    return_value = catch(:tag) { thrower.evaluate(new_invocation) }
-    assert_equal 'return-value', return_value
-  end
-end

data/test/unit/yield_parameters_test.rb

@@ -1,91 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/yield_parameters'
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
-
-class YieldParametersTest < Mocha::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