mocha 0.5.5 → 0.5.6

data/test/unit/object_inspect_test.rb

@@ -11,7 +11,7 @@ class ObjectInspectTest < Test::Unit::TestCase
     end
     object.attribute = 'instance_variable'
     assert_match Regexp.new("^#<Object:0x[0-9A-Fa-f]{1,8}.*>$"), object.mocha_inspect
-    assert_no_match /instance_variable/, object.mocha_inspect
+    assert_no_match(/instance_variable/, object.mocha_inspect)
   end
   
   def test_should_return_customized_string_representation_of_object
@@ -27,7 +27,9 @@ class ObjectInspectTest < Test::Unit::TestCase
     object.define_instance_accessor(:called)
     object.called = false
     object.replace_instance_method(:object_id) { self.called = true; 1 }
-    object.replace_instance_method(:id) { self.called = true; 1 }
+    if RUBY_VERSION < '1.9'
+      object.replace_instance_method(:id) { self.called = true; 1 }
+    end
     object.mocha_inspect
     assert_equal false, object.called
   end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -10,12 +10,12 @@ class AllOfTest < Test::Unit::TestCase
   
   def test_should_match_if_all_matchers_match
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(true), Stub::Matcher.new(true))
-    assert matcher == 'any_old_value'
+    assert matcher.matches?(['any_old_value'])
   end
   
   def test_should_not_match_if_any_matcher_does_not_match
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
-    assert matcher != 'any_old_value'
+    assert !matcher.matches?(['any_old_value'])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/any_of_test.rb

@@ -10,12 +10,12 @@ class AnyOfTest < Test::Unit::TestCase
   
   def test_should_match_if_any_matchers_match
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
-    assert matcher == 'any_old_value'
+    assert matcher.matches?(['any_old_value'])
   end
   
   def test_should_not_match_if_no_matchers_match
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(false), Stub::Matcher.new(false))
-    assert matcher != 'any_old_value'
+    assert !matcher.matches?(['any_old_value'])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/anything_test.rb

@@ -9,8 +9,8 @@ class AnythingTest < Test::Unit::TestCase
   
   def test_should_match_anything
     matcher = anything
-    assert matcher == :something
-    assert matcher == {'x' => 'y'}
+    assert matcher.matches?([:something])
+    assert matcher.matches?([{'x' => 'y'}])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/has_entries'
+require 'mocha/inspect'
+
+class HasEntriesTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_hash_including_specified_entries
+    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
+  end
+  
+  def test_should_not_match_hash_not_including_specified_entries
+    matcher = has_entries(:key_1 => 'value_2', :key_2 => 'value_2', :key_3 => 'value_3')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_describe_matcher
+    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
+    description = matcher.mocha_inspect
+    matches = /has_entries\((.*)\)/.match(description)
+    assert_not_nil matches[0]
+    entries = eval(matches[1])
+    assert_equal 'value_1', entries[:key_1]
+    assert_equal 'value_2', entries[:key_2]
+  end
+  
+end

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -7,19 +7,34 @@ class HasEntryTest < Test::Unit::TestCase
   
   include Mocha::ParameterMatchers
   
-  def test_should_match_hash_including_specified_entry
+  def test_should_match_hash_including_specified_key_value_pair
     matcher = has_entry(:key_1, 'value_1')
-    assert matcher == { :key_1 => 'value_1', :key_2 => 'value_2' }
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
   
-  def test_should_not_match_hash_not_including_specified_entry
+  def test_should_not_match_hash_not_including_specified_key_value_pair
     matcher = has_entry(:key_1, 'value_2')
-    assert matcher != { :key_1 => 'value_1', :key_2 => 'value_2' }
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_match_hash_including_specified_entry
+    matcher = has_entry(:key_1 => 'value_1')
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
   
-  def test_should_describe_matcher
+  def test_should_not_match_hash_not_including_specified_entry
+    matcher = has_entry(:key_1 => 'value_2')
+    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
+  end
+  
+  def test_should_describe_matcher_with_key_value_pair
     matcher = has_entry(:key_1, 'value_1')
     assert_equal "has_entry(:key_1, 'value_1')", matcher.mocha_inspect
   end
   
+  def test_should_describe_matcher_with_entry
+    matcher = has_entry(:key_1 => 'value_1')
+    assert_equal "has_entry(:key_1, 'value_1')", matcher.mocha_inspect
+  end
+  
 end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -9,12 +9,12 @@ class HasKeyTest < Test::Unit::TestCase
   
   def test_should_match_hash_including_specified_key
     matcher = has_key(:key_1)
-    assert matcher == { :key_1 => 1, :key_2 => 2 }
+    assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
   end
   
   def test_should_not_match_hash_not_including_specified_key
     matcher = has_key(:key_1)
-    assert matcher != { :key_2 => 2 }
+    assert !matcher.matches?([{ :key_2 => 2 }])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/has_value_test.rb

@@ -9,12 +9,12 @@ class HasValueTest < Test::Unit::TestCase
   
   def test_should_match_hash_including_specified_value
     matcher = has_value('value_1')
-    assert matcher == { :key_1 => 'value_1', :key_2 => 'value_2' }
+    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
   
   def test_should_not_match_hash_not_including_specified_value
     matcher = has_value('value_1')
-    assert matcher != { :key_2 => 'value_2' }
+    assert !matcher.matches?([{ :key_2 => 'value_2' }])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/includes_test.rb

@@ -9,12 +9,12 @@ class IncludesTest < Test::Unit::TestCase
 
   def test_should_match_object_including_value
     matcher = includes(:x)
-    assert matcher == [:x, :y, :z]
+    assert matcher.matches?([[:x, :y, :z]])
   end
 
   def test_should_not_match_object_that_does_not_include_value
     matcher = includes(:not_included)
-    assert matcher != [:x, :y, :z]
+    assert !matcher.matches?([[:x, :y, :z]])
   end
 
   def test_should_describe_matcher

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -9,12 +9,12 @@ class InstanceOfTest < Test::Unit::TestCase
 
   def test_should_match_object_that_is_an_instance_of_specified_class
     matcher = instance_of(String)
-    assert matcher == 'string'
+    assert matcher.matches?(['string'])
   end
 
   def test_should_not_match_object_that_is_not_an_instance_of_specified_class
     matcher = instance_of(String)
-    assert matcher != 99
+    assert !matcher.matches?([99])
   end
 
   def test_should_describe_matcher

data/test/unit/parameter_matchers/is_a_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/is_a'
+require 'mocha/inspect'
+
+class IsATest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_is_a_specified_class
+    matcher = is_a(Integer)
+    assert matcher.matches?([99])
+  end
+
+  def test_should_not_match_object_that_is_not_a_specified_class
+    matcher = is_a(Integer)
+    assert !matcher.matches?(['string'])
+  end
+
+  def test_should_describe_matcher
+    matcher = is_a(Integer)
+    assert_equal "is_a(Integer)", matcher.mocha_inspect
+  end
+
+end

data/test/unit/parameter_matchers/kind_of_test.rb

@@ -3,18 +3,18 @@ require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
 require 'mocha/parameter_matchers/kind_of'
 require 'mocha/inspect'
 
-class InstanceOfTest < Test::Unit::TestCase
+class KindOfTest < Test::Unit::TestCase
 
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_a_kind_of_specified_class
     matcher = kind_of(Integer)
-    assert matcher == 99
+    assert matcher.matches?([99])
   end
 
   def test_should_not_match_object_that_is_not_a_kind_of_specified_class
     matcher = kind_of(Integer)
-    assert matcher != 'string'
+    assert !matcher.matches?(['string'])
   end
 
   def test_should_describe_matcher

data/test/unit/parameter_matchers/not_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/not'
+require 'mocha/inspect'
+require 'stub_matcher'
+
+class NotTest < Test::Unit::TestCase
+  
+  include Mocha::ParameterMatchers
+  
+  def test_should_match_if_matcher_does_not_match
+    matcher = Not(Stub::Matcher.new(false))
+    assert matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_not_match_if_matcher_does_match
+    matcher = Not(Stub::Matcher.new(true))
+    assert !matcher.matches?(['any_old_value'])
+  end
+  
+  def test_should_describe_matcher
+    matcher = Not(Stub::Matcher.new(true))
+    assert_equal 'Not(matcher(true))', matcher.mocha_inspect
+  end
+  
+end

data/test/unit/parameter_matchers/regexp_matches_test.rb

@@ -9,12 +9,12 @@ class MatchesTest < Test::Unit::TestCase
   
   def test_should_match_parameter_matching_regular_expression
     matcher = regexp_matches(/oo/)
-    assert matcher == 'foo'
+    assert matcher.matches?(['foo'])
   end
   
   def test_should_not_match_parameter_not_matching_regular_expression
     matcher = regexp_matches(/oo/)
-    assert matcher != 'bar'
+    assert !matcher.matches?(['bar'])
   end
   
   def test_should_describe_matcher

data/test/unit/parameter_matchers/stub_matcher.rb

@@ -8,7 +8,8 @@ module Stub
       @matches = matches
     end
 
-    def ==(value)
+    def matches?(available_parameters)
+      value = available_parameters.shift
       @value = value
       @matches
     end

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/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