mocha 1.5.0 → 1.10.0

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -1,12 +1,11 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/has_entry'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasEntryTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_key_value_pair
@@ -62,7 +61,7 @@ class HasEntryTest < Mocha::TestCase
   def test_should_not_match_object_that_doesnt_respond_to_keys
     matcher = has_entry(:key_1 => equals('value_2'))
     object = Class.new do
-      def [](key)
+      def [](_key)
         'value_2'
       end
     end.new
@@ -81,49 +80,49 @@ class HasEntryTest < Mocha::TestCase
 
   def test_should_raise_argument_error_if_single_argument_is_not_a_hash
     e = assert_raises(ArgumentError) do
-      has_entry(Array.new)
+      has_entry([])
     end
-    assert_equal "Argument is not a Hash.", e.message
+    assert_equal 'Argument is not a Hash.', e.message
   end
 
   def test_should_raise_argument_error_if_no_entries_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry({})
     end
-    assert_equal "Argument has no entries.", e.message
+    assert_equal 'Argument has no entries.', e.message
   end
 
   def test_should_raise_argument_error_if_multiple_entries_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry(:key_1 => 'value_1', :key_2 => 'value_2')
     end
-    assert_equal "Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.", e.message
+    assert_equal 'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.', e.message
   end
 
   def test_should_raise_argument_error_if_more_than_two_arguments_are_supplied
     e = assert_raises(ArgumentError) do
       has_entry(1, 2, 3)
     end
-    assert_equal "Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).", e.message
+    assert_equal 'Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).', e.message
   end
 
   def test_should_match_array_as_key
     matcher = has_entry([:key_1, :key_2] => 'value_1')
-    assert matcher.matches?([{[:key_1, :key_2] => 'value_1', :key_3 => 'value_2'}])
+    assert matcher.matches?([{ [:key_1, :key_2] => 'value_1', :key_3 => 'value_2' }])
   end
 
   def test_should_match_array_as_value
-    matcher = has_entry(:key_1 => ['value_1', 'value_2'])
-    assert matcher.matches?([{:key_1 => ['value_1', 'value_2']}])
+    matcher = has_entry(:key_1 => %w[value_1 value_2])
+    assert matcher.matches?([{ :key_1 => %w[value_1 value_2] }])
   end
 
   def test_should_match_hash_as_value_and_key
-    matcher = has_entry({{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}})
-    assert matcher.matches?([{{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}, :key_5 => 'value_5'}])
+    matcher = has_entry({ :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' })
+    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
   end
 
   def test_should_match_matcher_as_value_and_key
-    matcher = has_entry({has_entry(:key_1 => 'value_1') => has_entry(:key_3 => 'value_3')})
-    assert matcher.matches?([{{:key_1 => 'value_1', :key_2 => 'value_2'} => {:key_3 => 'value_3', :key_4 => 'value_4'}, :key_5 => 'value_5'}])
+    matcher = has_entry(has_entry(:key_1 => 'value_1') => has_entry(:key_3 => 'value_3'))
+    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
   end
 end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -1,11 +1,10 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/has_key'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/inspect'
 
 class HasKeyTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_key

data/test/unit/parameter_matchers/has_value_test.rb

@@ -1,12 +1,11 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/has_value'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasValueTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_value
@@ -53,5 +52,4 @@ class HasValueTest < Mocha::TestCase
     matcher = has_value('value_1')
     assert !matcher.matches?(['value_1'])
   end
-
 end

data/test/unit/parameter_matchers/includes_test.rb

@@ -1,13 +1,12 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/includes'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/parameter_matchers/has_key'
 require 'mocha/parameter_matchers/regexp_matches'
 require 'mocha/inspect'
 
 class IncludesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_including_value
@@ -37,12 +36,12 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_describe_matcher_with_one_item
     matcher = includes(:x)
-    assert_equal "includes(:x)", matcher.mocha_inspect
+    assert_equal 'includes(:x)', matcher.mocha_inspect
   end
 
   def test_should_describe_matcher_with_multiple_items
     matcher = includes(:x, :y, :z)
-    assert_equal "includes(:x, :y, :z)", matcher.mocha_inspect
+    assert_equal 'includes(:x, :y, :z)', matcher.mocha_inspect
   end
 
   def test_should_not_raise_error_on_emtpy_arguments
@@ -67,12 +66,12 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_match_object_including_value_which_matches_nested_matcher
     matcher = includes(has_key(:key))
-    assert matcher.matches?([[:non_matching_element, {:key => 'value'}]])
+    assert matcher.matches?([[:non_matching_element, { :key => 'value' }]])
   end
 
   def test_should_not_match_object_which_doesnt_include_value_that_matches_nested_matcher
     matcher = includes(has_key(:key))
-    assert !matcher.matches?([[:non_matching_element, {:other_key => 'other-value'}]])
+    assert !matcher.matches?([[:non_matching_element, { :other_key => 'other-value' }]])
   end
 
   def test_should_match_string_argument_containing_substring
@@ -87,21 +86,21 @@ class IncludesTest < Mocha::TestCase
 
   def test_should_match_hash_argument_containing_given_key
     matcher = includes(:key)
-    assert matcher.matches?([{:thing => 1, :key => 2}])
+    assert matcher.matches?([{ :thing => 1, :key => 2 }])
   end
 
   def test_should_not_match_hash_argument_missing_given_key
     matcher = includes(:key)
-    assert !matcher.matches?([{:thing => 1, :other => :key}])
+    assert !matcher.matches?([{ :thing => 1, :other => :key }])
   end
 
   def test_should_match_hash_when_nested_matcher_matches_key
     matcher = includes(regexp_matches(/ar/))
-    assert matcher.matches?([{'foo' => 1, 'bar' => 2}])
+    assert matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
   end
 
   def test_should_not_match_hash_when_nested_matcher_doesn_not_match_key
     matcher = includes(regexp_matches(/az/))
-    assert !matcher.matches?([{'foo' => 1, 'bar' => 2}])
+    assert !matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
   end
 end

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/instance_of'
 require 'mocha/inspect'
 
 class InstanceOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_an_instance_of_specified_class
@@ -19,7 +18,6 @@ class InstanceOfTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = instance_of(String)
-    assert_equal "instance_of(String)", matcher.mocha_inspect
+    assert_equal 'instance_of(String)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/is_a_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/is_a'
 require 'mocha/inspect'
 
 class IsATest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_a_specified_class
@@ -19,7 +18,6 @@ class IsATest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = is_a(Integer)
-    assert_equal "is_a(Integer)", matcher.mocha_inspect
+    assert_equal 'is_a(Integer)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/kind_of_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/kind_of'
 require 'mocha/inspect'
 
 class KindOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_is_a_kind_of_specified_class
@@ -19,7 +18,6 @@ class KindOfTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = kind_of(Integer)
-    assert_equal "kind_of(Integer)", matcher.mocha_inspect
+    assert_equal 'kind_of(Integer)', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/not_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class NotTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_matcher_does_not_match
@@ -22,5 +21,4 @@ class NotTest < Mocha::TestCase
     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

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/regexp_matches'
 require 'mocha/inspect'
 
 class RegexpMatchesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_parameter_matching_regular_expression
@@ -19,7 +18,7 @@ class RegexpMatchesTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = regexp_matches(/oo/)
-    assert_equal "regexp_matches(/oo/)", matcher.mocha_inspect
+    assert_equal 'regexp_matches(/oo/)', matcher.mocha_inspect
   end
 
   def test_should_not_raise_error_on_empty_arguments

data/test/unit/parameter_matchers/responds_with_test.rb

@@ -1,11 +1,10 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/responds_with'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/inspect'
 
 class RespondsWithTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_parameter_responding_with_expected_value
@@ -20,7 +19,15 @@ class RespondsWithTest < Mocha::TestCase
 
   def test_should_match_parameter_responding_with_nested_responds_with_matcher
     matcher = responds_with(:foo, responds_with(:bar, 'baz'))
-    object = Class.new { def foo; Class.new { def bar; 'baz'; end }.new; end }.new
+    object = Class.new do
+      def foo
+        Class.new do
+          def bar
+            'baz'
+          end
+        end.new
+      end
+    end.new
     assert matcher.matches?([object])
   end
 
@@ -28,5 +35,4 @@ class RespondsWithTest < Mocha::TestCase
     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,7 +1,5 @@
 module Stub
-
   class Matcher
-
     attr_accessor :value
 
     def initialize(matches)
@@ -21,7 +19,5 @@ module Stub
     def to_matcher
       self
     end
-
   end
-
 end

data/test/unit/parameter_matchers/yaml_equivalent_test.rb

@@ -4,7 +4,6 @@ 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
@@ -19,7 +18,6 @@ class YamlEquivalentTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = yaml_equivalent([1, 2, 3])
-    assert_equal "yaml_equivalent([1, 2, 3])", matcher.mocha_inspect
+    assert_equal 'yaml_equivalent([1, 2, 3])', matcher.mocha_inspect
   end
-
 end

data/test/unit/parameters_matcher_test.rb

@@ -2,7 +2,6 @@ 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
@@ -101,14 +100,14 @@ class ParametersMatcherTest < Mocha::TestCase
   end
 
   def test_should_remove_curly_braces_if_hash_is_only_argument
-    params = [{:a => 1, :z => 2}]
+    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}]
+    params = [1, { :a => 1 }]
     parameters_matcher = ParametersMatcher.new(params)
     assert_equal '(1, {:a => 1})', parameters_matcher.mocha_inspect
   end
@@ -117,5 +116,4 @@ class ParametersMatcherTest < Mocha::TestCase
     parameters_matcher = ParametersMatcher.new
     assert_equal '(any_parameters)', parameters_matcher.mocha_inspect
   end
-
 end

data/test/unit/receivers_test.rb

@@ -4,13 +4,32 @@ require 'mocha/receivers'
 class ObjectReceiverTest < Mocha::TestCase
   include Mocha
 
-  class FakeObject < Struct.new(:mocha)
-    def is_a?(klass)
+  class FakeObject
+    def initialize(mocha)
+      @mocha = mocha
+    end
+
+    def mocha(_instantiate)
+      @mocha
+    end
+
+    def is_a?(_klass)
       false
     end
   end
 
-  class FakeClass < Struct.new(:superclass, :mocha)
+  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
@@ -35,14 +54,25 @@ 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, @mocha = superclass, mocha
+      @superclass = superclass
+      @mocha = mocha
     end
 
     def any_instance
-      Struct.new(:mocha).new(@mocha)
+      AnyInstance.new(@mocha)
     end
   end
 

data/test/unit/return_values_test.rb

@@ -1,63 +1,66 @@
 require File.expand_path('../../test_helper', __FILE__)
 
+require 'mocha/invocation'
 require 'mocha/return_values'
 
 class ReturnValuesTest < Mocha::TestCase
-
   include Mocha
 
+  def new_invocation
+    Invocation.new(:irrelevant, :irrelevant)
+  end
+
   def test_should_return_nil
     values = ReturnValues.new
-    assert_nil values.next
+    assert_nil values.next(new_invocation)
   end
 
   def test_should_keep_returning_nil
     values = ReturnValues.new
-    values.next
-    assert_nil values.next
-    assert_nil values.next
+    values.next(new_invocation)
+    assert_nil values.next(new_invocation)
+    assert_nil values.next(new_invocation)
   end
 
   def test_should_return_evaluated_single_return_value
     values = ReturnValues.new(SingleReturnValue.new('value'))
-    assert_equal 'value', values.next
+    assert_equal 'value', values.next(new_invocation)
   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
+    values.next(new_invocation)
+    assert_equal 'value', values.next(new_invocation)
+    assert_equal 'value', values.next(new_invocation)
   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
+    assert_equal 'value_1', values.next(new_invocation)
+    assert_equal 'value_2', values.next(new_invocation)
   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
+    values.next(new_invocation)
+    values.next(new_invocation)
+    assert_equal 'value_2', values.next(new_invocation)
+    assert_equal 'value_2', values.next(new_invocation)
   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
+    assert_equal 'value_1', values[0].evaluate(new_invocation)
+    assert_equal 'value_2', values[1].evaluate(new_invocation)
+    assert_equal 'value_3', values[2].evaluate(new_invocation)
   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
+    values1 = ReturnValues.build('value_1')
+    values2 = ReturnValues.build('value_2a', 'value_2b')
+    values = (values1 + values2).values
+    assert_equal 'value_1', values[0].evaluate(new_invocation)
+    assert_equal 'value_2a', values[1].evaluate(new_invocation)
+    assert_equal 'value_2b', values[2].evaluate(new_invocation)
   end
-
 end