spy 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb02855e84ed97ae778d5983b8bba3e5839a6593416336a18240beb759f82b7f
-  data.tar.gz: df92498cacaab913d6d71d6d3e34778140d7367f741a1f1d750e96cbc2353a19
+  metadata.gz: 46c870bafa6e5402e585dc44ea855f5e22a8087b4c14f70fad8794b39ac425a0
+  data.tar.gz: c9552993d8b0e335defead206a238c0342ea461102722f6702f04ae8a823f100
 SHA512:
-  metadata.gz: 72e822dfc3517b8bcc4d26d9ffc0db333acd4526673a765de0a19f4396292834bd0402a307d31d6ba226c5f9017a2813fba53738d5784dc00fc0aa0e66720869
-  data.tar.gz: 35b2c58f79ef8da6c462ba1a5739ddc2705df1544a2f75c14ecb9731c60b5f33337f94056dbf1803480699d6729f0410985194cbfe4d376852cf5417d352b8c2
+  metadata.gz: 5b476de3ea3a4f01a85ed3f99d51ed7c38785f67c9c7b565607e6e0edd027eeb643bc2fe43a92b8bdcfc7054e149c6e75022489bccaa3b7678f4239263152094
+  data.tar.gz: 16d976fa766805c685f7198fe219a55802d29a4d560ec7f984c229c751905c81fe0622a8887fc71c0c87845a48d40d283fdb4f0411d2c3ded2d72673bddfe1e1

data/.github/workflows/ruby.yml

@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@0a29871fe2b0200a17a4497bae54fe5df0d973aa # v1.115.3
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.tool-versions

@@ -1 +1 @@
-ruby 2.7.0
+ruby 3.1.2

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## Spy 1.0.4 (December 21th, 2022) ##
+
+* remove usage of #present? (@ryanong)
+
+## Spy 1.0.4 (December 21th, 2022) ##
+
+* Hash as argument got turned into keyword arguments (@svenpl)
+* drop support for ruby older than 2.7 (@ryanong)
+
+## Spy 1.0.3 (September 15, 2022) ##
+
+* Fix private method call errors for older ruby versions (@dylanahsmith)
+* `Spy.on_instance_method` and `and_call_through` on `#to_ary-able` class causes an error (@mizukami234)
+* Fix `and_return` on class method (@jfirebaugh)
+
+## Spy 1.0.2 (January 10, 2022) ##
+
+* Fix subroutine call with hash as last arg (@dtheo-ad)
+* Ruby 2.7+ support (@casperisfine)
+
 ## Spy 1.0.1 (August 20th, 2020) ##
 
 *   Fix call_through w/ instance methods (@lreeves)

data/README.md

@@ -9,8 +9,7 @@
 
 Spy is a lightweight stubbing framework with support for method spies, constant stubs, and object mocks.
 
-Spy supports ruby 2.1.0+.
-For versions less than 2.1 use v0.4.5
+Spy supports ruby 2.7.0+.
 
 Spy features that were completed were tested against the rspec-mocks tests so it covers all cases that rspec-mocks does.
 
@@ -47,7 +46,7 @@ Fail faster, code faster.
   * you can usually just check the call logs.
   * if you do need to use this. It is probably a code smell. You either need to abstract your method more or add separate tests.
 * you want to use dumb double, Spy has smart mocks, they are better
-* you use `mock_model` and `stub_model` (I want to impliment this soon)
+* you use `mock_model` and `stub_model`
 
 ## Installation
 
@@ -87,7 +86,7 @@ Spy::Subroutine.new(book, :flamethrower).hook(force:true).and_return("burnninant
 ```
 
 You can also stub instance methods of Classes and Modules. This is equivalent to
-rspec-mock's `Module#any_instance`
+rspec-mock's `allow_any_instance_of(Module)`
 
 ```ruby
 Spy.on_instance_method(Book, :title).and_return("Cannery Row")

data/lib/spy/call_log.rb

@@ -10,6 +10,9 @@ module Spy
     # @!attribute [r] args
     #   @return [Array] arguments were sent to the method
     #
+    # @!attribute [r] kwargs
+    #   @return [Array] keyword arguments were sent to the method
+    #
     # @!attribute [r] block
     #   @return [Proc] the block that was sent to the method
     #
@@ -17,10 +20,10 @@ module Spy
     #   @return The result of the method of being stubbed, or called through
 
 
-    attr_reader :object, :called_from, :args, :block, :result
+    attr_reader :object, :called_from, :args, :kwargs, :block, :result
 
-    def initialize(object, called_from, args, block, result)
-      @object, @called_from, @args, @block, @result = object, called_from, args, block, result
+    def initialize(object, called_from, args, kwargs, block, result)
+      @object, @called_from, @args, @kwargs, @block, @result = object, called_from, args, kwargs, block, result
     end
   end
 end

data/lib/spy/subroutine.rb

@@ -201,26 +201,28 @@ module Spy
     # check if the method was called with the exact arguments
     # @param args Arguments that should have been sent to the method
     # @return [Boolean]
-    def has_been_called_with?(*args, &block)
+    def has_been_called_with?(*args, **kwargs, &block)
       raise NeverHookedError unless @was_hooked
-      match = block_given? ? block : proc { |call| call.args == args }
+      match = block_given? ? block : proc { |call| call.args == args && call.kwargs == kwargs }
       calls.any?(&match)
     end
 
     # invoke that the method has been called. You really shouldn't use this
     # method.
-    def invoke(object, args, block, called_from)
-      check_arity!(args.size)
+    def invoke(object, args, kwargs, block, called_from)
+      arity = args.size
+      arity += 1 if !kwargs&.empty?
+      check_arity!(arity)
 
       result =
         if @call_through
-          call_plan(build_call_through_plan(object), block, *args)
+          call_plan(build_call_through_plan(object), block, *args, **kwargs)
         elsif @plan
           check_for_too_many_arguments!(@plan)
-          call_plan(@plan, block, *args)
+          call_plan(@plan, block, *args, **kwargs)
         end
     ensure
-      calls << CallLog.new(object, called_from, args, block, result)
+      calls << CallLog.new(object, called_from, args, kwargs, block, result)
     end
 
     # reset the call log
@@ -237,11 +239,12 @@ module Spy
     # we use eval to set the spy object id as a parameter so it can be extracted
     # and looked up later using `Method#parameters`
     SPY_ARGS_PREFIX='__spy_args_'.freeze
+    SPY_KWARGS_PREFIX='__spy_kwargs_'.freeze
     def override_method
       eval <<-METHOD, binding, __FILE__, __LINE__ + 1
       __method_spy__ = self
-      lambda do |*#{SPY_ARGS_PREFIX}#{self.object_id}, &block|
-        __method_spy__.invoke(self, #{SPY_ARGS_PREFIX}#{self.object_id}, block, caller(1)[0])
+      lambda do |*#{SPY_ARGS_PREFIX}#{self.object_id}, **#{SPY_KWARGS_PREFIX}#{self.object_id}, &block|
+        __method_spy__.invoke(self, #{SPY_ARGS_PREFIX}#{self.object_id}, #{SPY_KWARGS_PREFIX}#{self.object_id}, block, caller(1)[0])
       end
       METHOD
     end
@@ -345,23 +348,8 @@ module Spy
       end
     end
 
-    def call_plan(plan, block, *args)
-      if ruby_27_last_arg_hash?(args)
-        *prefix, last = args
-        plan.call(*prefix, **last, &block)
-      else
-        plan.call(*args, &block)
-      end
-    end
-
-    # Ruby 2.7 gives a deprecation warning about passing hash as last argument for a method
-    # with a double-splat operator (**), and Ruby 3 raises an ArgumentError exception.
-    # This checks if args has a hash as last element to extract it and pass it with double-splat to avoid an exception.
-    def ruby_27_last_arg_hash?(args)
-      last = args.last
-      last.instance_of?(Hash) &&
-        !last.empty? &&
-        Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+    def call_plan(plan, block, *args, **kwargs)
+      plan.call(*args, **kwargs, &block)
     end
 
     class << self

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "1.0.3"
+  VERSION = "1.0.5"
 end

data/spy.gemspec

@@ -6,7 +6,7 @@ require 'spy/version'
 Gem::Specification.new do |gem|
   gem.name          = "spy"
   gem.version       = Spy::VERSION
-  gem.required_ruby_version = '>= 2.1.0'
+  gem.required_ruby_version = '>= 2.7.0'
   gem.license       = 'MIT'
   gem.authors       = ["Ryan Ong"]
   gem.email         = ["ryanong@gmail.com"]

data/test/spy/test_subroutine.rb

@@ -150,6 +150,14 @@ module Spy
       assert_equal string, result
     end
 
+    def test_spy_and_call_through_with_hash_and_keyword_args
+      spy_on(@pen, 'hash_and_keyword_arg').and_call_through
+      hsh = { hello: 'world' }
+
+      assert_equal [hsh, nil], @pen.hash_and_keyword_arg(hsh)
+      assert_equal [hsh, 'foo'], @pen.hash_and_keyword_arg(hsh, keyword: 'foo')
+    end
+
     def test_spy_and_call_through_returns_original_method_result
       string = "hello world"
 
@@ -237,6 +245,20 @@ module Spy
       assert pen_write_spy.has_been_called_with?("hello")
     end
 
+    def test_has_been_called_with_kwargs
+      pen_write_spy = spy_on(@pen, :opt_kwargs)
+      refute pen_write_spy.has_been_called_with?("hello")
+
+      @pen.opt_kwargs("hello")
+      assert pen_write_spy.has_been_called_with?("hello")
+
+      @pen.opt_kwargs("world", opt: "hello")
+      assert pen_write_spy.has_been_called_with?("world", opt: "hello")
+
+      @pen.opt_kwargs("hello world", opt: "world", opt2: "hello")
+      assert pen_write_spy.has_been_called_with?("hello world", opt: "world", opt2: "hello")
+    end
+
     def test_spy_hook_records_number_of_calls2
       args = ["hello world"]
       block = Proc.new {}

data/test/support/pen.rb

@@ -37,6 +37,10 @@ class Pen
     write("#{hello} #{name}")
   end
 
+  def hash_and_keyword_arg(hsh, keyword: nil)
+    [hsh, keyword]
+  end
+
   def public_method
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - Ryan Ong
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -117,9 +117,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".tool-versions"
-- ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
@@ -139,22 +139,6 @@ files:
 - lib/spy/nest.rb
 - lib/spy/subroutine.rb
 - lib/spy/version.rb
-- spec/spec_helper.rb
-- spec/spy/and_call_original_spec.rb
-- spec/spy/and_yield_spec.rb
-- spec/spy/any_instance_spec.rb
-- spec/spy/hash_excluding_matcher_spec.rb
-- spec/spy/hash_including_matcher_spec.rb
-- spec/spy/mutate_const_spec.rb
-- spec/spy/nil_expectation_warning_spec.rb
-- spec/spy/null_object_mock_spec.rb
-- spec/spy/partial_mock_spec.rb
-- spec/spy/passing_argument_matchers_spec.rb
-- spec/spy/serialization_spec.rb
-- spec/spy/stash_spec.rb
-- spec/spy/stub_implementation_spec.rb
-- spec/spy/stub_spec.rb
-- spec/spy/to_ary_spec.rb
 - spy.gemspec
 - test/integration/test_api.rb
 - test/integration/test_class_method.rb
@@ -179,7 +163,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -192,22 +176,6 @@ specification_version: 4
 summary: A simple modern mocking library that uses the spy pattern and checks method's
   existence and arity.
 test_files:
-- spec/spec_helper.rb
-- spec/spy/and_call_original_spec.rb
-- spec/spy/and_yield_spec.rb
-- spec/spy/any_instance_spec.rb
-- spec/spy/hash_excluding_matcher_spec.rb
-- spec/spy/hash_including_matcher_spec.rb
-- spec/spy/mutate_const_spec.rb
-- spec/spy/nil_expectation_warning_spec.rb
-- spec/spy/null_object_mock_spec.rb
-- spec/spy/partial_mock_spec.rb
-- spec/spy/passing_argument_matchers_spec.rb
-- spec/spy/serialization_spec.rb
-- spec/spy/stash_spec.rb
-- spec/spy/stub_implementation_spec.rb
-- spec/spy/stub_spec.rb
-- spec/spy/to_ary_spec.rb
 - test/integration/test_api.rb
 - test/integration/test_class_method.rb
 - test/integration/test_constant_spying.rb

data/.travis.yml

@@ -1,13 +0,0 @@
-language: ruby
-rvm:
-  - '2.1'
-  - '2.5'
-  - '2.7'
-  - jruby
-  - ruby-head
-  - rbx-3
-matrix:
-  allow_failures:
-      - rvm: ruby-head
-      - rvm: rbx-3
-      - rvm: jruby

data/spec/spec_helper.rb

@@ -1,41 +0,0 @@
-require "rspec/core"
-require "rspec/matchers"
-require "rspec/expectations"
-require "spy"
-require "pry"
-require "pry-nav"
-
-RSpec::Matchers.define :include_method do |expected|
-  match do |actual|
-    actual.map { |m| m.to_s }.include?(expected.to_s)
-  end
-end
-
-RSpec.configure do |config|
-  config.color_enabled = true
-  config.order = :random
-  config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.filter_run_including :focus
-  config.filter_run_excluding :broken => true
-  config.mock_with :absolutely_nothing
-
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = :expect
-  end
-
-  old_verbose = nil
-  config.before(:each, :silence_warnings) do
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-  end
-
-  config.after(:each, :silence_warnings) do
-    $VERBOSE = old_verbose
-  end
-
-  config.after(:each) do
-    Spy.teardown
-  end
-end
-

data/spec/spy/and_call_original_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-describe "and_call_through" do
-  context "on a partial mock object" do
-    let(:klass) do
-      Class.new do
-        def meth_1
-          :original
-        end
-
-        def meth_2(x)
-          yield x, :additional_yielded_arg
-        end
-
-        def self.new_instance
-          new
-        end
-      end
-    end
-
-    let(:instance) { klass.new }
-
-    it 'passes the received message through to the original method' do
-      spy = Spy.on(instance, :meth_1).and_call_through
-      expect(instance.meth_1).to eq(:original)
-      expect(spy).to have_been_called
-    end
-
-    it 'passes args and blocks through to the original method' do
-      spy = Spy.on(instance, :meth_2).and_call_through
-      value = instance.meth_2(:submitted_arg) { |a, b| [a, b] }
-      expect(value).to eq([:submitted_arg, :additional_yielded_arg])
-      expect(spy).to have_been_called
-    end
-
-    it 'works for singleton methods' do
-      def instance.foo; :bar; end
-      spy = Spy.on(instance, :foo).and_call_through
-      expect(instance.foo).to eq(:bar)
-      expect(spy).to have_been_called
-    end
-
-    it 'works for methods added through an extended module' do
-      instance.extend Module.new { def foo; :bar; end }
-      spy = Spy.on(instance, :foo).and_call_through
-      expect(instance.foo).to eq(:bar)
-      expect(spy).to have_been_called
-    end
-
-    it "works for method added through an extended module onto a class's ancestor" do
-      sub_sub_klass = Class.new(Class.new(klass))
-      klass.extend Module.new { def foo; :bar; end }
-      spy = Spy.on(sub_sub_klass, :foo).and_call_through
-      expect(sub_sub_klass.foo).to eq(:bar)
-      expect(spy).to have_been_called
-    end
-
-    it "finds the method on the most direct ancestor even if the method " +
-       "is available on more distant ancestors" do
-      klass.extend Module.new { def foo; :klass_bar; end }
-      sub_klass = Class.new(klass)
-      sub_klass.extend Module.new { def foo; :sub_klass_bar; end }
-      spy = Spy.on(sub_klass, :foo).and_call_through
-      expect(sub_klass.foo).to eq(:sub_klass_bar)
-      expect(spy).to have_been_called
-    end
-
-    it 'works for class methods defined on a superclass' do
-      subclass = Class.new(klass)
-      spy = Spy.on(subclass, :new_instance).and_call_through
-      expect(subclass.new_instance).to be_a(subclass)
-      expect(spy).to have_been_called
-    end
-
-    it 'works for class methods defined on a grandparent class' do
-      sub_subclass = Class.new(Class.new(klass))
-      spy = Spy.on(sub_subclass, :new_instance).and_call_through
-      expect(sub_subclass.new_instance).to be_a(sub_subclass)
-      expect(spy).to have_been_called
-    end
-
-    it 'works for class methods defined on the Class class' do
-      spy = Spy.on(klass, :new).and_call_through
-      expect(klass.new).to be_an_instance_of(klass)
-      expect(spy).to have_been_called
-    end
-
-    it "works for instance methods defined on the object's class's superclass" do
-      subclass = Class.new(klass)
-      inst = subclass.new
-      spy = Spy.on(inst, :meth_1).and_call_through
-      expect(inst.meth_1).to eq(:original)
-      expect(spy).to have_been_called
-    end
-
-    it 'works for aliased methods' do
-      klass = Class.new do
-        class << self
-          alias alternate_new new
-        end
-      end
-
-      spy = Spy.on(klass, :alternate_new).and_call_through
-      expect(klass.alternate_new).to be_an_instance_of(klass)
-      expect(spy).to have_been_called
-    end
-
-    context 'on an object that defines method_missing' do
-      before do
-        klass.class_eval do
-          def respond_to_missing?(name, _)
-            if name.to_s == "greet_jack"
-              true
-            else
-              super
-            end
-          end
-
-          def method_missing(name, *args)
-            if name.to_s == "greet_jack"
-              "Hello, jack"
-            else
-              super
-            end
-          end
-        end
-      end
-
-      it 'works when the method_missing definition handles the message' do
-        spy = Spy.on(instance, :greet_jack).and_call_through
-        expect(instance.greet_jack).to eq("Hello, jack")
-        expect(spy).to have_been_called
-      end
-
-      it 'raises an error on invocation if method_missing does not handle the message' do
-        Spy::Subroutine.new(instance, :not_a_handled_message).hook(force: true).and_call_through
-
-        # Note: it should raise a NoMethodError (and usually does), but
-        # due to a weird rspec-expectations issue (see #183) it sometimes
-        # raises a `NameError` when a `be_xxx` predicate matcher has been
-        # recently used. `NameError` is the superclass of `NoMethodError`
-        # so this example will pass regardless.
-        # If/when we solve the rspec-expectations issue, this can (and should)
-        # be changed to `NoMethodError`.
-        expect {
-          instance.not_a_handled_message
-        }.to raise_error(NameError, /not_a_handled_message/)
-      end
-    end
-  end
-end
-

data/spec/spy/and_yield_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe "Spy" do
-
-  class Foo
-    def method_that_accepts_a_block(&block)
-    end
-  end
-
-  let(:obj) { Foo.new }
-
-  describe "#and_yield" do
-    context "with eval context as block argument" do
-
-      it "evaluates the supplied block as it is read" do
-        evaluated = false
-        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
-          evaluated = true
-        end
-        expect(evaluated).to be_true
-      end
-
-      it "passes an eval context object to the supplied block" do
-        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
-          expect(eval_context).not_to be_nil
-        end
-      end
-
-      it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do
-        expected_eval_context = nil
-        actual_eval_context = nil
-
-        Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
-          expected_eval_context = eval_context
-        end
-
-        obj.method_that_accepts_a_block do
-          actual_eval_context = self
-        end
-
-        expect(actual_eval_context).to equal(expected_eval_context)
-      end
-
-      context "and no yielded arguments" do
-
-        it "passes when expectations set on the eval context are met" do
-          configured_eval_context = nil
-          context_foo_spy = nil
-          Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
-            configured_eval_context = eval_context
-            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
-          end
-
-          obj.method_that_accepts_a_block do
-            foo
-          end
-
-          expect(context_foo_spy).to have_been_called
-        end
-
-        it "fails when expectations set on the eval context are not met" do
-          configured_eval_context = nil
-          context_foo_spy = nil
-          Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
-            configured_eval_context = eval_context
-            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
-          end
-
-          obj.method_that_accepts_a_block do
-            # foo is not called here
-          end
-
-          expect(context_foo_spy).to_not have_been_called
-        end
-
-      end
-
-      context "and yielded arguments" do
-
-        it "passes when expectations set on the eval context and yielded arguments are met" do
-          configured_eval_context = nil
-          yielded_arg = Object.new
-          context_foo_spy = nil
-          Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
-            configured_eval_context = eval_context
-            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
-            Spy::Subroutine.new(yielded_arg, :bar).hook(force: true)
-          end
-
-          obj.method_that_accepts_a_block do |obj|
-            obj.bar
-            foo
-          end
-
-          expect(context_foo_spy).to have_been_called
-          expect(Spy.get(yielded_arg, :bar)).to have_been_called
-        end
-
-        it "fails when expectations set on the eval context and yielded arguments are not met" do
-          configured_eval_context = nil
-          yielded_arg = Object.new
-          context_foo_spy = nil
-          Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
-            configured_eval_context = eval_context
-            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
-            Spy::Subroutine.new(yielded_arg, :bar).hook(force: true)
-          end
-
-          obj.method_that_accepts_a_block do |obj|
-            # obj.bar is not called here
-            # foo is not called here
-          end
-
-          expect(context_foo_spy).to_not have_been_called
-          expect(Spy.get(yielded_arg, :bar)).to_not have_been_called
-        end
-
-      end
-
-    end
-  end
-end
-