much-stub 0.1.2 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 948b3a6fa21e50a2a221b167fe768a5d65c7a61c135622fe6ced882a5e406b03
-  data.tar.gz: 700d700fab285da4620cb4fbd3b521a58a9ffeaf8d50afdcc96780810091e301
+  metadata.gz: 15204360d9518246e4abaa703670f75489b26364a262f61397956bcd6292bb91
+  data.tar.gz: e53db7a648e52be63ea31d6dc930d7c009e65604d05a4e1e447edcfb3ef7b296
 SHA512:
-  metadata.gz: fecb7b76d76bc9ff338461c7ec6a48ac3bf1833bd77f4f248c9d4a145fa0b0177b3ce9d99d01add632266d7f9c5731441f0ad553f14775e7cf704aaffc80099a
-  data.tar.gz: 55308114a2f7aac2294ba44aac2adf84152cc2213a40a9ff0118b3fe2e8d43738cbc617fb19855c63515e915bc46754fc915d86b568d7a9c97356fb619420156
+  metadata.gz: 5892e22dc64f46400a115d42fb7b7da3d5b82387fda5b8c2ec5f807d6a9b47e4dca5a92d86a3a97898d5f6e85885808065d591e53aba7d78303afc1396fce4a4
+  data.tar.gz: 4476a777e7ee869f59080f5c0bc40d2d8736d77d01588f193ea6e826f424d3abf110ca49a60437267e7e16d5578c2f6f74bb24ce810940af82154ce0e08e7199

data/.l.yml

@@ -0,0 +1,8 @@
+# https://github.com/redding/l.rb
+
+linters:
+  - name: "Rubocop"
+    cmd: "bundle exec rubocop"
+    extensions:
+      - ".rb"
+    cli_abbrev: "u"

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  much-style-guide:
+    - "lib/much-style-guide/rubocop.yml"

data/.ruby-version

@@ -0,0 +1 @@
+2.5.8

data/.t.yml

@@ -0,0 +1,6 @@
+# https://github.com/redding/t.rb
+
+default_cmd: bundle exec assert
+test_dir: test
+test_file_suffixes:
+  - "_tests.rb"

data/Gemfile

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby "~> 2.5"
+
 gemspec
 
-gem "pry", "~> 0.12.2"
+gem "pry"

data/README.md

@@ -110,24 +110,49 @@ my_object = my_class.new
 
 basic_method_called_with = nil
 MuchStub.(my_object, :basic_method) { |*args|
-  basic_method_called_with = args
+  basic_method_called_with = MuchStub::Call.new(*args)
+}
+# OR
+MuchStub.(my_object, :basic_method).on_call { |call|
+  basic_method_called_with = call
+}
+# OR
+MuchStub.on_call(my_object, :basic_method) { |call|
+  # MucStub.on_call(...) { ... } is equivalent to
+  # MuchStub.(...).on_call { ... }
+  basic_method_called_with = call
 }
 
 my_object.basic_method(123)
-basic_method_called_with
+basic_method_called_with.args
   # => [123]
 
-iterator_method_call_args = nil
-iterator_method_call_block = nil
+basic_method_called_with = nil
+MuchStub.(my_object, :basic_method).with(4, 5, 6) { |*args|
+  basic_method_called_with = MuchStub::Call.new(*args)
+}
+# OR
+MuchStub.(my_object, :basic_method).with(4, 5, 6).on_call { |call|
+  basic_method_called_with = call
+}
+
+my_object.basic_method(4, 5, 6)
+basic_method_called_with.args
+  # => [4,5,6]
+
+iterator_method_called_with = nil
 MuchStub.(my_object, :iterator_method) { |*args, &block|
-  iterator_method_call_args = args
-  iterator_method_call_block = block
+  iterator_method_called_with = MuchStub::Call.new(*args)
+}
+# OR
+MuchStub.(my_object, :iterator_method).on_call { |call|
+  iterator_method_called_with = call
 }
 
 my_object.iterator_method([1, 2, 3], &:to_s)
-iterator_method_call_args
+iterator_method_called_with.args
   # => [[1, 2, 3]]
-iterator_method_call_block
+iterator_method_called_with.block
   # => #<Proc:0x00007fb083a6feb0(&:to_s)>
 
 # Count method calls for spying.
@@ -145,13 +170,17 @@ basic_method_call_count
 
 basic_method_calls = []
 MuchStub.(my_object, :basic_method) { |*args|
-  basic_method_calls << args
+  basic_method_calls << MuchStub::Call.new(*args)
+}
+# OR
+MuchStub.(my_object, :basic_method).on_call { |call|
+  basic_method_calls << call
 }
 
 my_object.basic_method(123)
 basic_method_calls.size
   # => 1
-basic_method_calls.first
+basic_method_calls.first.args
   # => [123]
 ```
 
@@ -218,12 +247,16 @@ basic_method_called_with
 
 basic_method_called_with = nil
 MuchStub.tap(my_object, :basic_method) { |value, *args|
-  basic_method_called_with = args
+  basic_method_called_with = MuchStub::Call.new(*args)
+}
+# OR
+MuchStub.tap_on_call(my_object, :basic_method) { |value, call|
+  basic_method_called_with = call
 }
 
 my_object.basic_method(123)
   # => "123"
-basic_method_called_with
+basic_method_called_with.args
   # => [123]
 ```
 
@@ -266,6 +299,39 @@ thing.value
   # => 456
 ```
 
+### `MuchStub.spy`
+
+Use the `.spy` method to spy on method calls. This is especially helpful for spying on _chained_ method calls.
+
+```ruby
+# Given this object/API
+
+myclass = Class.new do
+  def one; self; end
+  def two(val); self; end
+  def three; self; end
+  def ready?; false; end
+end
+myobj = myclass.new
+
+spy =
+  MuchStub.spy(myobj :one, :two, :three, ready?: true)
+
+assert_equal spy, myobj.one
+assert_equal spy, myobj.two("a")
+assert_equal spy, myobj.three
+
+assert_true myobj.one.two("b").three.ready?
+
+assert_kind_of MuchStub::CallSpy, spy
+assert_equal 2, spy.one_call_count
+assert_equal 2, spy.two_call_count
+assert_equal 2, spy.three_call_count
+assert_equal 1, spy.ready_predicate_call_count
+assert_equal ["b"], spy.two_last_called_with.args
+assert_true spy.ready_predicate_called?
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/much-stub.rb

@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
 require "much-stub/version"
 
+require "much-stub/call"
+require "much-stub/call_spy"
+
 module MuchStub
   def self.stubs
     @stubs ||= {}
@@ -9,39 +14,72 @@ module MuchStub
     MuchStub::Stub.key(obj, meth)
   end
 
-  def self.call(*args, &block)
-    self.stub(*args, &block)
+  def self.arity_matches?(method, args)
+    # mandatory args
+    return true if method.arity == args.size
+    # variable args
+    return true if method.arity < 0 && args.size >= (method.arity + 1).abs
+
+    false
   end
 
   def self.stub(obj, meth, &block)
-    key = self.stub_key(obj, meth)
-    self.stubs[key] ||= MuchStub::Stub.new(obj, meth, caller_locations)
-    self.stubs[key].tap{ |s| s.do = block }
+    key = stub_key(obj, meth)
+    stubs[key] ||= MuchStub::Stub.new(obj, meth, caller_locations)
+    stubs[key].tap{ |s| s.do = block }
+  end
+
+  def self.call(*args, &block)
+    stub(*args, &block)
+  end
+
+  def self.stub_on_call(*args, &on_call_block)
+    stub(*args).on_call(&on_call_block)
+  end
+
+  def self.on_call(*args, &on_call_block)
+    stub_on_call(*args, &on_call_block)
   end
 
   def self.unstub(obj, meth)
-    key = self.stub_key(obj, meth)
-    (self.stubs.delete(key) || MuchStub::NullStub.new).teardown
+    key = stub_key(obj, meth)
+    (stubs.delete(key) || MuchStub::NullStub.new).teardown
   end
 
   def self.unstub!
-    self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
+    stubs.keys.each{ |key| stubs.delete(key).teardown }
   end
 
   def self.stub_send(obj, meth, *args, &block)
     orig_caller = caller_locations
-    stub = self.stubs.fetch(MuchStub::Stub.key(obj, meth)) do
+    stub = stubs.fetch(MuchStub::Stub.key(obj, meth)) do
       raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
     end
     stub.call_method(args, &block)
   end
 
   def self.tap(obj, meth, &tap_block)
-    self.stub(obj, meth) { |*args, &block|
-      self.stub_send(obj, meth, *args, &block).tap { |value|
-        tap_block.call(value, *args, &block) if tap_block
-      }
-    }
+    stub(obj, meth) do |*args, &block|
+      stub_send(obj, meth, *args, &block).tap do |value|
+        tap_block&.call(value, *args, &block)
+      end
+    end
+  end
+
+  def self.tap_on_call(obj, meth, &on_call_block)
+    tap(obj, meth) do |value, *args, &block|
+      on_call_block&.call(value, MuchStub::Call.new(*args, &block))
+    end
+  end
+
+  def self.spy(obj, *meths, **return_values)
+    MuchStub::CallSpy.new(**return_values).call_spy_tap do |spy|
+      meths.each do |meth|
+        stub(obj, meth) do |*args, &block|
+          spy.__send__(meth, *args, &block)
+        end
+      end
+    end
   end
 
   class Stub
@@ -75,11 +113,15 @@ module MuchStub
 
     def call(args, orig_caller = nil, &block)
       orig_caller ||= caller_locations
-      unless arity_matches?(args)
-        msg = "arity mismatch on `#{@method_name}`: " \
-              "expected #{number_of_args(@method.arity)}, " \
-              "called with #{args.size}"
-        raise StubArityError, msg, orig_caller.map(&:to_s)
+      unless MuchStub.arity_matches?(@method, args)
+        raise(
+          StubArityError.new(
+            @method,
+            args,
+            method_name: @method_name,
+            backtrace: orig_caller,
+          ),
+        )
       end
       lookup(args, orig_caller).call(*args, &block)
     rescue NotStubbedError
@@ -89,13 +131,31 @@ module MuchStub
 
     def with(*args, &block)
       orig_caller = caller_locations
-      unless arity_matches?(args)
-        msg = "arity mismatch on `#{@method_name}`: " \
-              "expected #{number_of_args(@method.arity)}, " \
-              "stubbed with #{args.size}"
-        raise StubArityError, msg, orig_caller.map(&:to_s)
+      unless MuchStub.arity_matches?(@method, args)
+        raise(
+          StubArityError.new(
+            @method,
+            args,
+            method_name: @method_name,
+            backtrace: orig_caller,
+          ),
+        )
       end
       @lookup[args] = block
+      self
+    end
+
+    def on_call(&on_call_block)
+      stub_block =
+        ->(*args, &block){
+          on_call_block&.call(MuchStub::Call.new(*args, &block))
+        }
+      if @lookup.empty?
+        @do = stub_block
+      elsif @lookup.value?(nil)
+        @lookup.transform_values!{ |value| value.nil? ? stub_block : value }
+      end
+      self
     end
 
     def teardown
@@ -106,7 +166,7 @@ module MuchStub
     end
 
     def inspect
-      "#<#{self.class}:#{"0x0%x" % (object_id << 1)}" \
+      "#<#{self.class}:#{format("0x0%x", (object_id << 1))}" \
       " @method_name=#{@method_name.inspect}" \
       ">"
     end
@@ -118,7 +178,7 @@ module MuchStub
         msg = "#{object.inspect} does not respond to `#{@method_name}`"
         raise StubError, msg, orig_caller.map(&:to_s)
       end
-      is_constant          = object.kind_of?(Module)
+      is_constant          = object.is_a?(Module)
       local_object_methods = object.methods(false).map(&:to_s)
       all_object_methods   = object.methods.map(&:to_s)
       if (is_constant && !local_object_methods.include?(@method_name)) ||
@@ -129,7 +189,8 @@ module MuchStub
         method
       end
 
-      if !local_object_methods.include?(@name) # already stubbed
+      # already stubbed
+      unless local_object_methods.include?(@name)
         @metaclass.send(:alias_method, @name, @method_name)
       end
       @method = object.method(@name)
@@ -144,20 +205,20 @@ module MuchStub
 
     def lookup(args, orig_caller)
       @lookup.fetch(args) do
-        self.do || begin
+        self.do ||
+        begin
           msg = "#{inspect_call(args)} not stubbed."
           inspect_lookup_stubs.tap do |stubs|
-            msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+            msg += "\nStubs:\n#{stubs}" unless stubs.empty?
           end
           raise NotStubbedError, msg, orig_caller.map(&:to_s)
         end
-      end
-    end
-
-    def arity_matches?(args)
-      return true if @method.arity == args.size # mandatory args
-      return true if @method.arity < 0 && args.size >= (@method.arity+1).abs # variable args
-      return false
+      end ||
+      raise(
+        StubError,
+        "#{inspect_call(args)} stubbed with no block.",
+        orig_caller.map(&:to_s),
+      )
     end
 
     def inspect_lookup_stubs
@@ -167,23 +228,38 @@ module MuchStub
     def inspect_call(args)
       "`#{@method_name}(#{args.map(&:inspect).join(",")})`"
     end
-
-    def number_of_args(arity)
-      if arity < 0
-        "at least #{(arity + 1).abs}"
-      else
-        arity
-      end
-    end
   end
 
   StubError       = Class.new(ArgumentError)
   NotStubbedError = Class.new(StubError)
-  StubArityError  = Class.new(StubError)
+  StubArityError  =
+    Class.new(StubError) do
+      def initialize(method, args, method_name:, backtrace:)
+        msg = "arity mismatch on `#{method_name}`: " \
+              "expected #{number_of_args(method.arity)}, " \
+              "called with #{args.size}"
 
-  NullStub = Class.new do
-    def teardown; end # no-op
-  end
+        super(msg)
+        set_backtrace(Array(backtrace).map(&:to_s))
+      end
+
+      private
+
+      def number_of_args(arity)
+        if arity < 0
+          "at least #{(arity + 1).abs}"
+        else
+          arity
+        end
+      end
+    end
+
+  NullStub =
+    Class.new do
+      def teardown
+        # no-op
+      end
+    end
 
   module ParameterList
     LETTERS = ("a".."z").to_a.freeze
@@ -196,8 +272,6 @@ module MuchStub
       params.join(", ")
     end
 
-    private
-
     def self.get_arity(object, method_name)
       object.method(method_name).arity
     rescue NameError