mocha 1.8.0 → 1.13.0

data/test/unit/parameter_matchers/regexp_matches_test.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/regexp_matches'
-require 'mocha/inspect'
-
-class RegexpMatchesTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_parameter_matching_regular_expression
-    matcher = regexp_matches(/oo/)
-    assert matcher.matches?(['foo'])
-  end
-
-  def test_should_not_match_parameter_not_matching_regular_expression
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?(['bar'])
-  end
-
-  def test_should_describe_matcher
-    matcher = regexp_matches(/oo/)
-    assert_equal 'regexp_matches(/oo/)', matcher.mocha_inspect
-  end
-
-  def test_should_not_raise_error_on_empty_arguments
-    matcher = regexp_matches(/oo/)
-    assert_nothing_raised { matcher.matches?([]) }
-  end
-
-  def test_should_not_match_on_empty_arguments
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?([])
-  end
-
-  def test_should_not_raise_error_on_argument_that_does_not_respond_to_equals_tilde
-    object_not_responding_to_equals_tilde = Class.new { undef =~ }.new
-    matcher = regexp_matches(/oo/)
-    assert_nothing_raised { matcher.matches?([object_not_responding_to_equals_tilde]) }
-  end
-
-  def test_should_not_match_on_argument_that_does_not_respond_to_equals_tilde
-    object_not_responding_to_equals_tilde = Class.new { undef =~ }.new
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?([object_not_responding_to_equals_tilde])
-  end
-end

data/test/unit/parameter_matchers/responds_with_test.rb

@@ -1,38 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/responds_with'
-require 'mocha/parameter_matchers/object'
-require 'mocha/inspect'
-
-class RespondsWithTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_parameter_responding_with_expected_value
-    matcher = responds_with(:upcase, 'FOO')
-    assert matcher.matches?(['foo'])
-  end
-
-  def test_should_not_match_parameter_responding_with_unexpected_value
-    matcher = responds_with(:upcase, 'FOO')
-    assert !matcher.matches?(['bar'])
-  end
-
-  def test_should_match_parameter_responding_with_nested_responds_with_matcher
-    matcher = responds_with(:foo, responds_with(:bar, 'baz'))
-    object = Class.new do
-      def foo
-        Class.new do
-          def bar
-            'baz'
-          end
-        end.new
-      end
-    end.new
-    assert matcher.matches?([object])
-  end
-
-  def test_should_describe_matcher
-    matcher = responds_with(:foo, :bar)
-    assert_equal 'responds_with(:foo, :bar)', matcher.mocha_inspect
-  end
-end

data/test/unit/parameter_matchers/stub_matcher.rb

@@ -1,23 +0,0 @@
-module Stub
-  class Matcher
-    attr_accessor :value
-
-    def initialize(matches)
-      @matches = matches
-    end
-
-    def matches?(available_parameters)
-      value = available_parameters.shift
-      @value = value
-      @matches
-    end
-
-    def mocha_inspect
-      "matcher(#{@matches})"
-    end
-
-    def to_matcher
-      self
-    end
-  end
-end

data/test/unit/parameter_matchers/yaml_equivalent_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/yaml_equivalent'
-require 'mocha/inspect'
-
-class YamlEquivalentTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_parameter_matching_yaml_representation_of_object
-    matcher = yaml_equivalent([1, 2, 3])
-    assert matcher.matches?(["--- \n- 1\n- 2\n- 3\n"])
-  end
-
-  def test_should_not_match_parameter_matching_yaml_representation_of_object
-    matcher = yaml_equivalent([1, 2, 3])
-    assert !matcher.matches?(["--- \n- 4\n- 5\n"])
-  end
-
-  def test_should_describe_matcher
-    matcher = yaml_equivalent([1, 2, 3])
-    assert_equal 'yaml_equivalent([1, 2, 3])', matcher.mocha_inspect
-  end
-end

data/test/unit/parameters_matcher_test.rb

@@ -1,119 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/parameters_matcher'
-
-class ParametersMatcherTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_match_any_actual_parameters_if_no_expected_parameters_specified
-    parameters_matcher = ParametersMatcher.new
-    assert parameters_matcher.match?([1, 2, 3])
-  end
-
-  def test_should_match_if_actual_parameters_are_same_as_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert parameters_matcher.match?([4, 5, 6])
-  end
-
-  def test_should_not_match_if_actual_parameters_are_different_from_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert !parameters_matcher.match?([1, 2, 3])
-  end
-
-  def test_should_not_match_if_there_are_less_actual_parameters_than_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert !parameters_matcher.match?([4, 5])
-  end
-
-  def test_should_not_match_if_there_are_more_actual_parameters_than_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5])
-    assert !parameters_matcher.match?([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([4, 5, optionals])
-    assert !parameters_matcher.match?([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([4, 5, optionals])
-    assert parameters_matcher.match?([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([4, 5, optionals])
-    assert parameters_matcher.match?([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([4, 5, optionals])
-    assert parameters_matcher.match?([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([4, 5, optionals])
-    assert !parameters_matcher.match?([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([4, 5, optionals])
-    assert !parameters_matcher.match?([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([4, 5, optionals])
-    assert !parameters_matcher.match?([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([4, 5, optionals])
-    assert !parameters_matcher.match?([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?([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?([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/receivers_test.rb

@@ -1,96 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/receivers'
-
-class ObjectReceiverTest < Mocha::TestCase
-  include Mocha
-
-  class FakeObject
-    def initialize(mocha)
-      @mocha = mocha
-    end
-
-    def mocha(_instantiate)
-      @mocha
-    end
-
-    def is_a?(_klass)
-      false
-    end
-  end
-
-  class FakeClass
-    attr_reader :superclass
-
-    def initialize(superclass, mocha)
-      @superclass = superclass
-      @mocha = mocha
-    end
-
-    def mocha(_instantiate)
-      @mocha
-    end
-
-    def is_a?(klass)
-      klass == Class
-    end
-  end
-
-  def test_mocks_returns_mock_for_object
-    object = FakeObject.new(:mocha)
-    receiver = ObjectReceiver.new(object)
-    assert_equal [:mocha], receiver.mocks
-  end
-
-  def test_mocks_returns_mocks_for_class_and_its_superclasses
-    grandparent = FakeClass.new(nil, :grandparent_mocha)
-    parent = FakeClass.new(grandparent, :parent_mocha)
-    klass = FakeClass.new(parent, :mocha)
-    receiver = ObjectReceiver.new(klass)
-    assert_equal [:mocha, :parent_mocha, :grandparent_mocha], receiver.mocks
-  end
-end
-
-class AnyInstanceReceiverTest < Mocha::TestCase
-  include Mocha
-
-  class FakeAnyInstanceClass
-    class AnyInstance
-      def initialize(mocha)
-        @mocha = mocha
-      end
-
-      def mocha(_instantiate)
-        @mocha
-      end
-    end
-
-    attr_reader :superclass
-
-    def initialize(superclass, mocha)
-      @superclass = superclass
-      @mocha = mocha
-    end
-
-    def any_instance
-      AnyInstance.new(@mocha)
-    end
-  end
-
-  def test_mocks_returns_mocks_for_class_and_its_superclasses
-    grandparent = FakeAnyInstanceClass.new(nil, :grandparent_mocha)
-    parent = FakeAnyInstanceClass.new(grandparent, :parent_mocha)
-    klass = FakeAnyInstanceClass.new(parent, :mocha)
-    receiver = AnyInstanceReceiver.new(klass)
-    assert_equal [:mocha, :parent_mocha, :grandparent_mocha], receiver.mocks
-  end
-end
-
-class DefaultReceiverTest < Mocha::TestCase
-  include Mocha
-
-  def test_mocks_returns_mock
-    mock = :mocha
-    receiver = DefaultReceiver.new(mock)
-    assert_equal [:mocha], receiver.mocks
-  end
-end

data/test/unit/return_values_test.rb

@@ -1,61 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/return_values'
-
-class ReturnValuesTest < Mocha::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
-    values1 = ReturnValues.build('value_1')
-    values2 = ReturnValues.build('value_2a', 'value_2b')
-    values = (values1 + values2).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

@@ -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,12 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/single_return_value'
-
-class SingleReturnValueTest < Mocha::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

@@ -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,18 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/thrower'
-
-class ThrowerTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_throw_tag
-    thrower = Thrower.new(:tag)
-    assert_throws(:tag) { thrower.evaluate }
-  end
-
-  def test_should_throw_tag_with_return_value
-    thrower = Thrower.new(:tag, 'return-value')
-    return_value = catch(:tag) { thrower.evaluate }
-    assert_equal 'return-value', return_value
-  end
-end