spy 1.0.1 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa89505674a7286f055ee019988cf29debbdd5cb7e525a022864f551d20ae842
-  data.tar.gz: fa61fa5e78f5aea6fab75bcc471bdcc8032182d8e9c7528e9370b91022ef7ae0
+  metadata.gz: 46c870bafa6e5402e585dc44ea855f5e22a8087b4c14f70fad8794b39ac425a0
+  data.tar.gz: c9552993d8b0e335defead206a238c0342ea461102722f6702f04ae8a823f100
 SHA512:
-  metadata.gz: abb91b0bcef139e03b90cb59f2f1b5d9f0c52c8137beafab301f56a96d44dbcffc203bcf0c69cd7e5376bed68549e0bb9bf407b4f85e07fc91d875d401ce39d0
-  data.tar.gz: 58d355373220b031ba5740b0cfdc2a6d9bb94a7c39166fafae23896342eec3c3b907994f7224e80abc7f2d1ae289048d98cd56a05750569befa62c98f6330a22
+  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

@@ -33,6 +33,7 @@ module Spy
       @base_object, @method_name = object, method_name
       @singleton_method = singleton_method
       @plan = nil
+      @call_through = false
       reset!
     end
 
@@ -58,14 +59,14 @@ module Spy
 
       if singleton_method
         if base_object.singleton_class.method_defined?(method_name) || base_object.singleton_class.private_method_defined?(method_name)
-          base_object.singleton_class.alias_method(method_name, method_name)
+          base_object.singleton_class.send(:alias_method, method_name, method_name)
         end
         base_object.define_singleton_method(method_name, override_method)
       else
         if base_object.method_defined?(method_name) || base_object.private_method_defined?(method_name)
-          base_object.alias_method(method_name, method_name)
+          base_object.send(:alias_method, method_name, method_name)
         end
-        base_object.define_method(method_name, override_method)
+        base_object.send(:define_method, method_name, override_method)
       end
 
       if [:public, :protected, :private].include? hook_opts[:visibility]
@@ -83,7 +84,7 @@ module Spy
       raise NeverHookedError, "'#{method_name}' method has not been hooked" unless hooked?
 
       method_owner.send(:remove_method, method_name)
-      if original_method && method_owner == original_method.owner
+      if original_method
         original_method.owner.send(:define_method, method_name, original_method)
         original_method.owner.send(original_method_visibility, method_name) if original_method_visibility
       end
@@ -148,28 +149,7 @@ module Spy
     # tells the spy to call the original method
     # @return [self]
     def and_call_through
-      if @base_object.is_a? Class
-        @plan = Proc.new do |object, *args, &block|
-          if original_method
-            if original_method.is_a? UnboundMethod
-              bound_method = original_method.bind(object)
-              bound_method.call(*args, &block)
-            else
-              original_method.call(*args, &block)
-            end
-          else
-            base_object.send(:method_missing, method_name, *args, &block)
-          end
-        end
-      else
-        @plan = Proc.new do |*args, &block|
-          if original_method
-            original_method.call(*args, &block)
-          else
-            base_object.send(:method_missing, method_name, *args, &block)
-          end
-        end
-      end
+      @call_through = true
 
       self
     end
@@ -221,30 +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)
-
-      if base_object.is_a? Class
-        result = if @plan
-                   check_for_too_many_arguments!(@plan)
-                   @plan.call(object, *args, &block)
-                 end
-      else
-        result = if @plan
-                   check_for_too_many_arguments!(@plan)
-                   @plan.call(*args, &block)
-                 end
-      end
+    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, **kwargs)
+        elsif @plan
+          check_for_too_many_arguments!(@plan)
+          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
@@ -261,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
@@ -355,6 +334,24 @@ module Spy
       @method_owner ||= current_method.owner
     end
 
+    def build_call_through_plan(object)
+      if original_method
+        if @base_object.is_a?(Class) && original_method.is_a?(UnboundMethod)
+          original_method.bind(object)
+        else
+          original_method
+        end
+      else
+        Proc.new do |*args, &block|
+          base_object.send(:method_missing, method_name, *args, &block)
+        end
+      end
+    end
+
+    def call_plan(plan, block, *args, **kwargs)
+      plan.call(*args, **kwargs, &block)
+    end
+
     class << self
 
       # retrieve the method spy from an object or create a new one

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "1.0.1"
+  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/integration/test_class_method.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class TestClassMethod < Minitest::Test
+  def teardown
+    Spy::Agency.instance.dissolve!
+  end
+
+  def test_and_return
+    klass = Class.new do
+      def self.class_method(*args, &block)
+      end
+    end
+    received_args = nil
+    received_block = nil
+    Spy.on(klass, :class_method).and_return do |*args, &block|
+      received_args = args
+      received_block = block
+    end
+    block = -> {}
+    klass.class_method(:a, :b, &block)
+    assert_equal [:a, :b], received_args
+    assert_equal block, received_block
+  end
+end

data/test/spy/test_subroutine.rb

@@ -6,6 +6,10 @@ module Spy
       Subroutine.new(base_object, method_name).hook
     end
 
+    def spy_on_instance_method(base_object, method_name)
+      Subroutine.new(base_object, method_name, false).hook
+    end
+
     def setup
       @pen = Pen.new
     end
@@ -109,6 +113,15 @@ module Spy
       assert_empty @pen.written
     end
 
+    def test_spy_and_return_can_call_a_block_with_hash
+      result = "hello world"
+
+      spy_on(@pen, :write_hash).and_return { |**opts| opts[:test] }
+
+      assert_equal result, @pen.write_hash(test: result)
+      assert_empty @pen.written
+    end
+
     def test_spy_and_return_can_call_a_block_raises_when_there_is_an_arity_mismatch
       write_spy = spy_on(@pen, :write)
       write_spy.and_return do |*args|
@@ -137,6 +150,81 @@ 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"
+
+      write_spy = spy_on(@pen, :write).and_call_through
+      another_spy = spy_on(@pen, :another).and_call_through
+
+      result = @pen.write(string)
+
+      assert_equal string, result
+      assert write_spy.has_been_called?
+      assert_equal 'another', @pen.another
+      assert another_spy.has_been_called?
+    end
+
+    def test_spy_and_call_through_with_hash_original_method
+      string = 'test:hello world'
+
+      write_spy = spy_on(@pen, :write_hash).and_call_through
+
+      @pen.write_hash(test: 'hello world')
+      assert_equal string, @pen.written.last
+      assert write_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_returns_original_method_result
+      string = "hello world"
+
+      inst_write_spy = spy_on_instance_method(Pen, :write).and_call_through
+      inst_another_spy = spy_on_instance_method(Pen, :another).and_call_through
+
+      result = @pen.write(string)
+
+      assert_equal string, result
+      assert inst_write_spy.has_been_called?
+      assert_equal 'another', @pen.another
+      assert inst_another_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_with_hash
+      string = 'test:hello world'
+
+      inst_write_spy = spy_on_instance_method(Pen, :write_hash).and_call_through
+
+      @pen.write_hash(test: 'hello world')
+
+      assert_equal string, @pen.written.last
+      assert inst_write_spy.has_been_called?
+    end
+
+    def test_spy_on_instance_and_call_through_to_aryable
+      to_aryable = Class.new do
+        def hello
+          'hello'
+        end
+
+        def to_ary
+          [1]
+        end
+      end
+
+      inst_hello_spy = spy_on_instance_method(to_aryable, :hello).and_call_through
+      inst = to_aryable.new
+
+      assert_equal 'hello', inst.hello
+      assert inst_hello_spy.has_been_called?
+    end
+
     def test_spy_hook_records_number_of_calls
       pen_write_spy = spy_on(@pen, :write)
       assert_equal 0, pen_write_spy.calls.size
@@ -157,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/spy/test_unhook.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module Spy
+  class TestUnhook < Minitest::Test
+    module ModuleFunctionStyle
+      extend self
+
+      def hello
+        'hello world'
+      end
+    end
+
+    module Injected
+      def hello
+        'hello world'
+      end
+    end
+
+    class ModuleInjectedStyle
+      include Injected
+    end
+
+    class ModuleExtendedStyle
+      extend Injected
+    end
+
+    class SingletonMethodStyle
+      def self.hello
+        'hello world'
+      end
+    end
+
+    class InstanceMethodStyle
+      def hello
+        'hello world'
+      end
+    end
+
+    def test_ModuleFunctionStyle
+      spy = Spy.on(ModuleFunctionStyle, :hello).and_return('yo')
+      assert_equal ModuleFunctionStyle.hello, 'yo'
+      spy.unhook
+      assert_equal ModuleFunctionStyle.hello, 'hello world'
+    end
+
+    def test_ModuleInjectedStyle
+      instance = ModuleInjectedStyle.new
+      spy = Spy.on(instance, :hello).and_return('yo')
+      assert_equal instance.hello, 'yo'
+      spy.unhook
+      assert_equal instance.hello, 'hello world'
+    end
+
+    def test_ModuleExtendedStyle
+      spy = Spy.on(ModuleExtendedStyle, :hello).and_return('yo')
+      assert_equal ModuleExtendedStyle.hello, 'yo'
+      spy.unhook
+      assert_equal ModuleExtendedStyle.hello, 'hello world'
+    end
+
+    def test_SingletonMethodStyle
+      spy = Spy.on(SingletonMethodStyle, :hello).and_return('yo')
+      assert_equal SingletonMethodStyle.hello, 'yo'
+      spy.unhook
+      assert_equal SingletonMethodStyle.hello, 'hello world'
+    end
+
+    def test_InstanceMethodStyle
+      instance = InstanceMethodStyle.new
+      spy = Spy.on(instance, :hello).and_return('yo')
+      assert_equal instance.hello, 'yo'
+      spy.unhook
+      assert_equal instance.hello, 'hello world'
+    end
+  end
+end

data/test/support/pen.rb

@@ -27,10 +27,20 @@ class Pen
     end
   end
 
+  def write_hash(**params)
+    params.each do |p|
+      write(p.join(':'))
+    end
+  end
+
   def greet(hello = "hello", name)
     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.1
+  version: 1.0.5
 platform: ruby
 authors:
 - Ryan Ong
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-20 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,37 +139,23 @@ 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
 - test/integration/test_constant_spying.rb
 - test/integration/test_instance_method.rb
 - test/integration/test_mocking.rb
 - test/integration/test_subroutine_spying.rb
 - test/spy/test_mock.rb
 - test/spy/test_subroutine.rb
+- test/spy/test_unhook.rb
 - test/support/pen.rb
 - test/test_helper.rb
 homepage: https://github.com/ryanong/spy
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -177,41 +163,27 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.17
+signing_key:
 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
 - test/integration/test_instance_method.rb
 - test/integration/test_mocking.rb
 - test/integration/test_subroutine_spying.rb
 - test/spy/test_mock.rb
 - test/spy/test_subroutine.rb
+- test/spy/test_unhook.rb
 - test/support/pen.rb
 - test/test_helper.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