mocha 1.10.0 → 1.11.2

data/lib/mocha/parameter_matchers/has_key.rb

@@ -20,11 +20,10 @@ module Mocha
     #   object.expects(:method_1).with(has_key('key_1'))
     #   object.method_1('key_2' => 2)
     #   # error raised, because method_1 was not called with Hash containing key: 'key_1'
-    # rubocop:disable Naming/PredicateName
-    def has_key(key)
+    #
+    def has_key(key) # rubocop:disable Naming/PredicateName
       HasKey.new(key)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected key.
     class HasKey < Base

data/lib/mocha/parameter_matchers/has_value.rb

@@ -20,11 +20,10 @@ module Mocha
     #   object.expects(:method_1).with(has_value(1))
     #   object.method_1('key_2' => 2)
     #   # error raised, because method_1 was not called with Hash containing value: 1
-    # rubocop:disable Naming/PredicateName
-    def has_value(value)
+    #
+    def has_value(value) # rubocop:disable Naming/PredicateName
       HasValue.new(value)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected value.
     class HasValue < Base

data/lib/mocha/parameter_matchers/is_a.rb

@@ -21,11 +21,10 @@ module Mocha
     #   object.expects(:method_1).with(is_a(Integer))
     #   object.method_1('string')
     #   # error raised, because method_1 was not called with an Integer
-    # rubocop:disable Naming/PredicateName
-    def is_a(klass)
+    #
+    def is_a(klass) # rubocop:disable Naming/PredicateName
       IsA.new(klass)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter is a specific class.
     class IsA < Base

data/lib/mocha/parameter_matchers/not.rb

@@ -20,11 +20,10 @@ module Mocha
     #   object.expects(:method_1).with(Not(includes(1)))
     #   object.method_1([0, 1, 2, 3])
     #   # error raised, because method_1 was not called with object not including 1
-    # rubocop:disable Naming/MethodName
-    def Not(matcher)
+    #
+    def Not(matcher) # rubocop:disable Naming/MethodName
       Not.new(matcher)
     end
-    # rubocop:enable Naming/MethodName
 
     # Parameter matcher which inverts the logic of the specified matcher using a logical NOT operation.
     class Not < Base

data/lib/mocha/state_machine.rb

@@ -84,11 +84,10 @@ module Mocha
     end
 
     # Provides a mechanism to determine whether the {StateMachine} is not in the state specified by +state_name+ at some point in the future.
-    # rubocop:disable Naming/PredicateName
-    def is_not(state_name)
+    #
+    def is_not(state_name) # rubocop:disable Naming/PredicateName
       StatePredicate.new(self, state_name)
     end
-    # rubocop:enable Naming/PredicateName
 
     # @private
     def mocha_inspect

data/lib/mocha/stubbed_method.rb

@@ -74,7 +74,7 @@ module Mocha
     def restore_original_method
       return if use_prepended_module_for_stub_method?
       if stub_method_overwrites_original_method?
-        original_method_owner.send(:define_method, method_name, method_body(original_method))
+        original_method_owner.send(:define_method, method_name, method_body(@original_method))
       end
       retain_original_visibility(original_method_owner)
     end
@@ -93,18 +93,16 @@ module Mocha
     private
 
     def retain_original_visibility(method_owner)
-      return unless original_visibility
-      Module.instance_method(original_visibility).bind(method_owner).call(method_name)
+      return unless @original_visibility
+      Module.instance_method(@original_visibility).bind(method_owner).call(method_name)
     end
 
-    attr_reader :original_method, :original_visibility
-
     def store_original_method_visibility
       @original_visibility = original_method_owner.__method_visibility__(method_name)
     end
 
     def stub_method_overwrites_original_method?
-      original_method && original_method.owner == original_method_owner
+      @original_method && @original_method.owner == original_method_owner
     end
 
     def remove_original_method_from_stubbee

data/lib/mocha/version.rb

@@ -1,3 +1,3 @@
 module Mocha
-  VERSION = '1.10.0'.freeze
+  VERSION = '1.11.2'.freeze
 end

data/lib/mocha/yield_parameters.rb

@@ -1,7 +1,3 @@
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
-
 module Mocha
   class YieldParameters
     def initialize
@@ -10,18 +6,16 @@ module Mocha
 
     def next_invocation
       case @parameter_groups.length
-      when 0 then NoYields.new
+      when 0 then []
       when 1 then @parameter_groups.first
       else @parameter_groups.shift
       end
     end
 
-    def add(*parameters)
-      @parameter_groups << SingleYield.new(*parameters)
-    end
-
-    def multiple_add(*parameter_groups)
-      @parameter_groups << MultipleYields.new(*parameter_groups)
+    def add(*parameter_groups)
+      @parameter_groups << parameter_groups.map do |pg|
+        pg.is_a?(Array) ? pg : [pg]
+      end
     end
   end
 end

data/test/acceptance/acceptance_test_helper.rb

@@ -1,6 +1,7 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'test_runner'
 require 'mocha/configuration'
+require 'mocha/mockery'
 require 'introspection'
 
 if Mocha::Detection::MiniTest.testcase && (ENV['MOCHA_RUN_INTEGRATION_TESTS'] != 'test-unit')

data/test/acceptance/display_matching_invocations_alongside_expectations_test.rb

@@ -31,7 +31,7 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     test_result = run_as_test do
       foo = mock('foo')
       foo.expects(:bar).with(1).returns('a')
-      foo.stubs(:bar).with(any_parameters).multiple_yields(%w[b c], %w[d e]).returns('f').raises(StandardError).throws(:tag, 'value')
+      foo.stubs(:bar).with(any_parameters).multiple_yields('bc', %w[d e]).returns('f').raises(StandardError).throws(:tag, 'value')
 
       foo.bar(1, 2) { |_ignored| }
       assert_raises(StandardError) { foo.bar(3, 4) { |_ignored| } }
@@ -40,9 +40,9 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     assert_invocations(
       test_result,
       '- allowed any number of times, invoked 3 times: #<Mock:foo>.bar(any_parameters)',
-      '  - #<Mock:foo>.bar(1, 2) # => "f" after yielding ("b", "c"), then ("d", "e")',
-      '  - #<Mock:foo>.bar(3, 4) # => raised StandardError after yielding ("b", "c"), then ("d", "e")',
-      '  - #<Mock:foo>.bar(5, 6) # => threw (:tag, "value") after yielding ("b", "c"), then ("d", "e")'
+      '  - #<Mock:foo>.bar(1, 2) { ... } # => "f" after yielding ("bc"), then ("d", "e")',
+      '  - #<Mock:foo>.bar(3, 4) { ... } # => raised StandardError after yielding ("bc"), then ("d", "e")',
+      '  - #<Mock:foo>.bar(5, 6) { ... } # => threw (:tag, "value") after yielding ("bc"), then ("d", "e")'
     )
   end
 
@@ -57,7 +57,7 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     assert_invocations(
       test_result,
       '- allowed any number of times, invoked once: #<Mock:foo>.bar(any_parameters)',
-      '  - #<Mock:foo>.bar(1, 2) # => nil after yielding ()'
+      '  - #<Mock:foo>.bar(1, 2) { ... } # => nil after yielding ()'
     )
   end
 

data/test/acceptance/failure_messages_test.rb

@@ -58,4 +58,20 @@ class FailureMessagesTest < Mocha::TestCase
     end
     assert_match Regexp.new(%("Foo")), test_result.failures[0].message
   end
+
+  def test_should_display_that_block_was_expected
+    test_result = run_as_test do
+      foo = mock
+      foo.expects(:bar).with_block_given
+    end
+    assert_match Regexp.new(' with block given$'), test_result.failures[0].message
+  end
+
+  def test_should_display_that_block_was_not_expected
+    test_result = run_as_test do
+      foo = mock
+      foo.expects(:bar).with_no_block_given
+    end
+    assert_match Regexp.new(' with no block given$'), test_result.failures[0].message
+  end
 end

data/test/acceptance/issue_457_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../acceptance_test_helper', __FILE__)
+
+class Issue457Test < Mocha::TestCase
+  include AcceptanceTest
+
+  def setup
+    setup_acceptance_test
+  end
+
+  def teardown
+    teardown_acceptance_test
+  end
+
+  def test_only_inspect_objects_when_necessary
+    test_result = run_as_test do
+      klass = Class.new do
+        def message
+          raise 'Not inspectable in this state!'
+        end
+
+        def inspect
+          message
+        end
+      end
+      instance = klass.new
+      instance.stubs(:message).returns('message')
+      assert_equal 'message', instance.inspect
+    end
+    assert_passed(test_result)
+  end
+end

data/test/acceptance/mocha_example_test.rb

@@ -1,6 +1,16 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path('../acceptance_test_helper', __FILE__)
 
 class MochaExampleTest < Mocha::TestCase
+  include AcceptanceTest
+
+  def setup
+    setup_acceptance_test
+  end
+
+  def teardown
+    teardown_acceptance_test
+  end
+
   class Rover
     def initialize(left_track, right_track, steps_per_metre, steps_per_degree)
       @left_track = left_track

data/test/acceptance/mock_built_with_first_argument_type_being_string_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path('../acceptance_test_helper', __FILE__)
+require 'deprecation_disabler'
+
+class MockBuiltWithFirstArgumentTypeBeingStringTest < Mocha::TestCase
+  include AcceptanceTest
+
+  def setup
+    setup_acceptance_test
+  end
+
+  def teardown
+    teardown_acceptance_test
+  end
+
+  def test_mock_built_with_single_symbol_argument_with_satisfied_expectation
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        m = mock(:my_method)
+        assert_nil m.my_method
+      end
+      expected_warning = 'Explicitly include `my_method` in Hash of expected methods vs return values, e.g. `mock(:my_method => nil)`.'
+      assert_equal expected_warning, Mocha::Deprecation.messages.last
+    end
+    assert_passed(test_result)
+  end
+
+  def test_mock_built_with_single_symbol_argument_with_unsatisfied_expectation
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        mock(:my_method)
+      end
+    end
+    assert_failed(test_result)
+    assert(test_result.failure_message_lines.any? do |line|
+      line[/expected exactly once, invoked never\: #<Mock\:0x[0-9a-f]+>\.my_method\(any_parameters\)/]
+    end)
+  end
+
+  def test_stub_built_with_single_symbol_argument
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        s = stub(:my_method)
+        assert_nil s.my_method
+      end
+      expected_warning = 'Explicitly include `my_method` in Hash of stubbed methods vs return values, e.g. `stub(:my_method => nil)`.'
+      assert_equal expected_warning, Mocha::Deprecation.messages.last
+    end
+    assert_passed(test_result)
+  end
+
+  def test_mock_built_with_first_argument_a_symbol_and_second_argument_a_hash
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        s = mock(:my_method, :another_method => 123)
+        assert_nil s.my_method
+      end
+      expected_warning = 'In this case the 2nd argument for `mock(:#my_method, ...)` is ignored, but in the future a Hash of expected methods vs return values will be respected.'
+      assert Mocha::Deprecation.messages.last(2).include?(expected_warning)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_stub_built_with_first_argument_a_symbol_and_second_argument_a_hash
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        s = stub(:my_method, :another_method => 123)
+        assert_nil s.my_method
+      end
+      expected_warning = 'In this case the 2nd argument for `stub(:#my_method, ...)` is ignored, but in the future a Hash of stubbed methods vs return values will be respected.'
+      assert Mocha::Deprecation.messages.last(2).include?(expected_warning)
+    end
+    assert_passed(test_result)
+  end
+
+  def test_stub_everything_built_with_single_symbol_argument
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        s = stub_everything(:my_method)
+        assert_nil s.my_method
+      end
+      expected_warning = 'Explicitly include `my_method` in Hash of stubbed methods vs return values, e.g. `stub_everything(:my_method => nil)`.'
+      assert_equal expected_warning, Mocha::Deprecation.messages.last
+    end
+    assert_passed(test_result)
+  end
+
+  def test_stub_everything_built_with_first_argument_a_symbol_and_second_argument_a_hash
+    test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        s = stub_everything(:my_method, :another_method => 123)
+        assert_nil s.my_method
+      end
+      expected_warning = 'In this case the 2nd argument for `stub_everything(:#my_method, ...)` is ignored, but in the future a Hash of stubbed methods vs return values will be respected.' # rubocop:disable Metrics/LineLength
+      assert Mocha::Deprecation.messages.last(2).include?(expected_warning)
+    end
+    assert_passed(test_result)
+  end
+end

data/test/acceptance/mock_test.rb

@@ -1,7 +1,11 @@
 require File.expand_path('../acceptance_test_helper', __FILE__)
+require 'mocha/configuration'
+require 'mocha/deprecation'
+require 'deprecation_disabler'
 
 class MockTest < Mocha::TestCase
   include AcceptanceTest
+  include Mocha
 
   def setup
     setup_acceptance_test
@@ -39,9 +43,13 @@ class MockTest < Mocha::TestCase
 
   def test_should_build_symbol_named_mock_and_explicitly_add_an_expectation_which_is_satisfied
     test_result = run_as_test do
-      foo = mock(:foo)
-      foo.expects(:bar)
-      foo.bar
+      Mocha::Configuration.override(:reinstate_undocumented_behaviour_from_v1_9 => false) do
+        DeprecationDisabler.disable_deprecations do
+          foo = mock(:foo)
+          foo.expects(:bar)
+          foo.bar
+        end
+      end
     end
     assert_passed(test_result)
   end
@@ -56,8 +64,10 @@ class MockTest < Mocha::TestCase
 
   def test_should_build_symbol_named_mock_and_explicitly_add_an_expectation_which_is_not_satisfied
     test_result = run_as_test do
-      foo = mock(:foo)
-      foo.expects(:bar)
+      DeprecationDisabler.disable_deprecations do
+        foo = mock(:foo)
+        foo.expects(:bar)
+      end
     end
     assert_failed(test_result)
   end
@@ -98,9 +108,13 @@ class MockTest < Mocha::TestCase
 
   def test_should_build_symbol_named_mock_incorporating_two_expectations_which_are_satisifed
     test_result = run_as_test do
-      foo = mock(:foo, :bar => 'bar', :baz => 'baz')
-      foo.bar
-      foo.baz
+      Mocha::Configuration.override(:reinstate_undocumented_behaviour_from_v1_9 => false) do
+        DeprecationDisabler.disable_deprecations do
+          foo = mock(:foo, :bar => 'bar', :baz => 'baz')
+          foo.bar
+          foo.baz
+        end
+      end
     end
     assert_passed(test_result)
   end
@@ -115,8 +129,10 @@ class MockTest < Mocha::TestCase
 
   def test_should_build_symbol_named_mock_incorporating_two_expectations_the_first_of_which_is_not_satisifed
     test_result = run_as_test do
-      foo = mock(:foo, :bar => 'bar', :baz => 'baz')
-      foo.baz
+      DeprecationDisabler.disable_deprecations do
+        foo = mock(:foo, :bar => 'bar', :baz => 'baz')
+        foo.baz
+      end
     end
     assert_failed(test_result)
   end
@@ -131,9 +147,45 @@ class MockTest < Mocha::TestCase
 
   def test_should_build_symbol_named_mock_incorporating_two_expectations_the_second_of_which_is_not_satisifed
     test_result = run_as_test do
-      foo = mock(:foo, :bar => 'bar', :baz => 'baz')
-      foo.bar
+      DeprecationDisabler.disable_deprecations do
+        foo = mock(:foo, :bar => 'bar', :baz => 'baz')
+        foo.bar
+      end
     end
     assert_failed(test_result)
   end
+
+  class Foo
+    class << self
+      attr_accessor :logger
+    end
+
+    def use_the_mock
+      self.class.logger.log('Foo was here')
+    end
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def test_should_display_deprecation_warning_if_mock_receives_invocations_in_another_test
+    use_mock_test_result = run_as_test do
+      Foo.logger = mock('Logger')
+      Foo.logger.expects(:log).with('Foo was here')
+      Foo.new.use_the_mock
+    end
+    assert_passed(use_mock_test_result)
+
+    reuse_mock_test_result = run_as_test do
+      DeprecationDisabler.disable_deprecations do
+        Foo.logger.expects(:log).with('Foo was here')
+        Foo.new.use_the_mock
+      end
+    end
+    assert_passed(reuse_mock_test_result)
+    assert message = Deprecation.messages.last
+    assert message.include?('#<Mock:Logger> was instantiated in one test but it is receiving invocations within another test.')
+    assert message.include?('This can lead to unintended interactions between tests and hence unexpected test failures.')
+    assert message.include?('Ensure that every test correctly cleans up any state that it introduces.')
+    assert message.include?('A Mocha::StubbingError will be raised in this scenario in the future.')
+  end
+  # rubocop:enable Metrics/AbcSize
 end