much-stub 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 948b3a6fa21e50a2a221b167fe768a5d65c7a61c135622fe6ced882a5e406b03
-  data.tar.gz: 700d700fab285da4620cb4fbd3b521a58a9ffeaf8d50afdcc96780810091e301
+  metadata.gz: 25518cd79915a42ef00d555f2f09db36b19ec52237054c1fb763667ff0a5c4d0
+  data.tar.gz: edbd7bd553731a3084806768ad3d956b7f086212b095dfaf63e9eff0ba56cc4e
 SHA512:
-  metadata.gz: fecb7b76d76bc9ff338461c7ec6a48ac3bf1833bd77f4f248c9d4a145fa0b0177b3ce9d99d01add632266d7f9c5731441f0ad553f14775e7cf704aaffc80099a
-  data.tar.gz: 55308114a2f7aac2294ba44aac2adf84152cc2213a40a9ff0118b3fe2e8d43738cbc617fb19855c63515e915bc46754fc915d86b568d7a9c97356fb619420156
+  metadata.gz: eb69a558eb21bbd717bb9164a5142c318697ea512e0234dd110c0127eaa9eef68a25abd13c2d9c4136dc9474712312a85fb5af8a30fc7dcaf8c7b1cc6d8606c4
+  data.tar.gz: 390126be543ddf6c36fcf7dd3c0491c5530ba8535b049b91edf9de6a3461895f5b4f673d2ef0b5b920af30880e71ea705f1043648edef75ede03b9c1af74b311

data/README.md

@@ -110,24 +110,43 @@ 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
 }
 
 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 +164,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 +241,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 +293,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,8 @@
 require "much-stub/version"
 
+require "much-stub/call"
+require "much-stub/call_spy"
+
 module MuchStub
   def self.stubs
     @stubs ||= {}
@@ -9,6 +12,12 @@ module MuchStub
     MuchStub::Stub.key(obj, meth)
   end
 
+  def self.arity_matches?(method, 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
+
   def self.call(*args, &block)
     self.stub(*args, &block)
   end
@@ -44,6 +53,22 @@ module MuchStub
     }
   end
 
+  def self.tap_on_call(obj, meth, &on_call_block)
+    self.tap(obj, meth) { |value, *args, &block|
+      on_call_block.call(value, MuchStub::Call.new(*args, &block)) if on_call_block
+    }
+  end
+
+  def self.spy(obj, *meths, **return_values)
+    MuchStub::CallSpy.new(**return_values).tap do |spy|
+      meths.each do |meth|
+        self.stub(obj, meth) { |*args, &block|
+          spy.public_send(meth, *args, &block)
+        }
+      end
+    end
+  end
+
   class Stub
     def self.key(object, method_name)
       "--#{object.object_id}--#{method_name}--"
@@ -75,11 +100,13 @@ 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 +116,29 @@ 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 on_call_block
+        }
+      if @lookup.empty?
+        @do = stub_block
+      elsif @lookup.has_value?(nil)
+        @lookup.transform_values!{ |value| value.nil? ? stub_block : value }
+      end
+      self
     end
 
     def teardown
@@ -143,7 +186,7 @@ module MuchStub
     end
 
     def lookup(args, orig_caller)
-      @lookup.fetch(args) do
+      @lookup.fetch(args) {
         self.do || begin
           msg = "#{inspect_call(args)} not stubbed."
           inspect_lookup_stubs.tap do |stubs|
@@ -151,13 +194,11 @@ module MuchStub
           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
+      } ||
+        raise(
+          StubError,
+          "#{inspect_call(args)} stubbed with no block.",
+          orig_caller.map(&:to_s))
     end
 
     def inspect_lookup_stubs
@@ -167,19 +208,31 @@ 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}"
+
+        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; end # no-op

data/lib/much-stub/call.rb

@@ -0,0 +1,15 @@
+module MuchStub
+  class Call
+    attr_reader :pargs, :kargs, :block
+
+    def initialize(*pargs, **kargs, &block)
+      @pargs = pargs.empty? ? nil : pargs
+      @kargs = kargs.empty? ? nil : kargs
+      @block = block
+    end
+
+    def args
+      @args ||= [*pargs, kargs].compact
+    end
+  end
+end

data/lib/much-stub/call_spy.rb

@@ -0,0 +1,91 @@
+require "much-stub/call"
+
+module MuchStub
+  class CallSpy
+    METHOD_NAME_REPLACEMENTS = {
+      "!" => "_bang",
+      "?" => "_predicate"
+    }.freeze
+
+    def initialize(**return_values)
+      @call_spy_return_values = return_values.transform_keys{ |key| key.to_s }
+
+      @call_spy_method_calls = Hash.new { |hash, key| hash[key] = [] }
+      @call_spy_method_return_values =
+        Hash.new { |hash, key| hash[key] = call_spy_return_value_proc(key) }
+    end
+
+    private
+
+    def call_spy_method_return_value(method_name, much_stub_call)
+      @call_spy_method_return_values[method_name.to_s].call(much_stub_call)
+    end
+
+    def call_spy_return_value_proc(method_name)
+      value = @call_spy_return_values[method_name]
+      return value if value.respond_to?(:call)
+
+      ->(*) { value.nil? ? self : value }
+    end
+
+    def call_spy_normalize_method_name(name)
+      METHOD_NAME_REPLACEMENTS.reduce(name.to_s) { |acc, (source, replacement)|
+        acc.gsub(source, replacement)
+      }
+    end
+
+    def call_spy_define_spied_method(name)
+      method_name = call_spy_normalize_method_name(name)
+      self.define_singleton_method(name) do |*args, &block|
+        call = MuchStub::Call.new(*args, &block)
+        @call_spy_method_calls[method_name] << call
+        call_spy_method_return_value(name, call)
+      end
+    end
+
+    def call_spy_define_query_method(query_method_match)
+      spied_method_name = query_method_match[1]
+      query_method_suffix = query_method_match[2]
+      method_name = call_spy_normalize_method_name(spied_method_name)
+      self.define_singleton_method("#{method_name}#{query_method_suffix}") do
+        yield(method_name) if block_given?
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if (match = name.match(/(\w+)(_calls)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          @call_spy_method_calls[method_name]
+        end
+        self.send(name, *args, &block)
+      elsif (match = name.match(/(\w+)(_last_called_with)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          self.send("#{method_name}_calls").last
+        end
+        self.send(name, *args, &block)
+      elsif (match = name.match(/(\w+)(_called_with)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          self.send("#{method_name}_last_called_with")
+        end
+        self.send(name, *args, &block)
+      elsif (match = name.match(/(\w+)(_call_count)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          self.send("#{method_name}_calls").size
+        end
+        self.send(name, *args, &block)
+      elsif (match = name.match(/(\w+)(_called\?)\z/))
+        call_spy_define_query_method(match) do |method_name|
+          self.send("#{method_name}_call_count") > 0
+        end
+        self.send(name, *args, &block)
+      else
+        call_spy_define_spied_method(name)
+        self.send(name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(*args)
+      super
+    end
+  end
+end

data/lib/much-stub/version.rb

@@ -1,3 +1,3 @@
 module MuchStub
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/much-stub.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.18.0"])
+  gem.required_ruby_version = "~> 2.5"
+
+  gem.add_development_dependency("assert", ["~> 2.18.1"])
 
 end

data/test/unit/call_spy_tests.rb

@@ -0,0 +1,96 @@
+require "assert"
+require "much-stub/call_spy"
+
+require "test/support/factory"
+
+class MuchStub::CallSpy
+  class UnitTests < Assert::Context
+    desc "MuchStub::CallSpy"
+    setup do
+      @unit_class = MuchStub::CallSpy
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    before do
+      @spy = @unit_class.new
+    end
+    subject{ @spy }
+
+    should "spy on method calls and return itself" do
+      assert_false subject.respond_to?(:get)
+
+      assert_equal [], subject.get_calls
+      assert_nil subject.get_last_called_with
+      assert_nil subject.get_called_with
+      assert_equal 0, subject.get_call_count
+      assert_false subject.get_called?
+
+      assert_same subject, subject.get
+
+      assert_true subject.respond_to?(:get)
+
+      assert_kind_of Array, subject.get_calls
+      assert_kind_of MuchStub::Call, subject.get_last_called_with
+      assert_equal [], subject.get_last_called_with.args
+      assert_equal subject.get_last_called_with, subject.get_called_with
+      assert_equal 1, subject.get_call_count
+      assert_true subject.get_called?
+
+      assert_same subject, subject.set!("value1")
+      assert_same subject, subject.set!("value2")
+
+      assert_kind_of Array, subject.set_bang_calls
+      assert_kind_of MuchStub::Call, subject.set_bang_last_called_with
+      assert_equal ["value2"], subject.set_bang_last_called_with.args
+      assert_equal 2, subject.set_bang_call_count
+      assert_true subject.set_bang_called?
+    end
+
+    should "normalize method names in call query methods" do
+      assert_same subject, subject.set!("value1")
+      assert_kind_of Array, subject.set_bang_calls
+      assert_kind_of MuchStub::Call, subject.set_bang_last_called_with
+      assert_equal ["value1"], subject.set_bang_last_called_with.args
+      assert_equal ["value1"], subject.set_bang_called_with.args
+      assert_equal 1, subject.set_bang_call_count
+      assert_true subject.set_bang_called?
+
+      assert_same subject, subject.any?
+      assert_kind_of Array, subject.any_predicate_calls
+      assert_kind_of MuchStub::Call, subject.any_predicate_last_called_with
+      assert_kind_of MuchStub::Call, subject.any_predicate_called_with
+      assert_equal 1, subject.any_predicate_call_count
+      assert_true subject.any_predicate_called?
+    end
+  end
+
+  class InitWithReturnValuesTests < UnitTests
+    desc "when init with return values"
+    setup do
+      @spy = @unit_class.new(any?: false)
+    end
+    subject{ @spy }
+
+    should "return the given values instead of itself if that method is called" do
+      assert_false subject.get.set!("value1").any?
+      assert_true subject.get_called?
+      assert_equal ["value1"], subject.set_bang_called_with.args
+      assert_true subject.any_predicate_called?
+    end
+  end
+
+  class InitWithReturnValueProcsTests < UnitTests
+    desc "when init with return value procs"
+    setup do
+      @result = Factory.boolean
+      @spy = @unit_class.new(any?: ->(call) { @result })
+    end
+    subject{ @spy }
+
+    should "return the value of calling the procs instead of itself" do
+      assert_equal @result, subject.get.set!("value1").any?
+    end
+  end
+end

data/test/unit/call_tests.rb

@@ -0,0 +1,68 @@
+require "assert"
+require "much-stub/call"
+
+require "test/support/factory"
+
+class MuchStub::Call
+  class UnitTests < Assert::Context
+    desc "MuchStub::Call"
+    setup do
+      @unit_class = MuchStub::Call
+
+      @pargs = [Factory.string, Factory.integer]
+      @kargs = {
+        one: 1,
+        two: 2
+      }
+      @block = -> {}
+    end
+  end
+
+  class InitWithNoArgsTests < UnitTests
+    desc "when init with no args"
+    subject{ @unit_class.new }
+
+    should "know its attrs" do
+      assert_nil subject.pargs
+      assert_nil subject.kargs
+      assert_equal [], subject.args
+      assert_nil subject.block
+    end
+  end
+
+  class InitWithOnlyPositionalArgsTests < UnitTests
+    desc "when init with only positional args"
+    subject{ @unit_class.new(*@pargs) }
+
+    should "know its attrs" do
+      assert_equal @pargs, subject.pargs
+      assert_nil subject.kargs
+      assert_equal [*@pargs], subject.args
+      assert_nil subject.block
+    end
+  end
+
+  class InitWithOnlyKeywordArgsTests < UnitTests
+    desc "when init with only keyword args"
+    subject{ @unit_class.new(**@kargs) }
+
+    should "know its attrs" do
+      assert_nil subject.pargs
+      assert_equal @kargs, subject.kargs
+      assert_equal [@kargs], subject.args
+      assert_nil subject.block
+    end
+  end
+
+  class InitWithBothPositionalAndKeywordArgsTests < UnitTests
+    desc "when init with only keyword args"
+    subject{ @unit_class.new(*@pargs, **@kargs, &@block) }
+
+    should "know its attrs" do
+      assert_equal @pargs, subject.pargs
+      assert_equal @kargs, subject.kargs
+      assert_equal [*@pargs, @kargs], subject.args
+      assert_equal @block, subject.block
+    end
+  end
+end

data/test/unit/much-stub_tests.rb

@@ -86,6 +86,48 @@ module MuchStub
       assert_equal @orig_value, @myobj.mymeth
       assert_equal [], my_meth_called_with
     end
+
+    should "be able to add a stub tap with an on_call block" do
+      my_meth_called_with = nil
+      MuchStub.tap_on_call(@myobj, :mymeth){ |value, call|
+        my_meth_called_with = call
+      }
+
+      assert_equal @orig_value, @myobj.mymeth
+      assert_equal [], my_meth_called_with.args
+    end
+
+    should "be able to add a stubbed spy" do
+      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?
+    end
   end
 
   class StubTests < UnitTests
@@ -134,21 +176,26 @@ module MuchStub
         @myobj.mymeth
       end
 
+      MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
+        @myobj.mymeth
       end
     end
 
+    should "complain when called if no lookup block was given" do
+      MuchStub::Stub.new(@myobj, :myval).with(1)
+
+      err = assert_raises(MuchStub::StubError){ @myobj.myval(1) }
+      assert_includes "stubbed with no block.",       err.message
+      assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
+    end
+
     should "complain if stubbing a method that the object doesn't respond to" do
       err = assert_raises(MuchStub::StubError){ MuchStub::Stub.new(@myobj, :some_other_meth) }
       assert_includes "does not respond to",     err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
     end
 
-    should "complain if stubbed and called with no `do` proc given" do
-      assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
-    end
-
     should "complain if stubbed and called with mismatched arity" do
       MuchStub::Stub.new(@myobj, :myval){ "myval" }
       err = assert_raises(MuchStub::StubArityError){ @myobj.myval }
@@ -227,20 +274,29 @@ module MuchStub
 
     should "stub methods with variable args" do
       assert_equal [1,2], @myobj.myargs(1,2)
+
       stub = MuchStub::Stub.new(@myobj, :myargs){ |*args| args.join(",") }
-      assert_equal "1,2", @myobj.myargs(1,2)
-      assert_equal "3,4,5", @myobj.myargs(3,4,5)
-      stub.with(3,4,5){ "three-four-five" }
-      assert_equal "three-four-five", @myobj.myargs(3,4,5)
+      assert_equal "1,2,3", @myobj.myargs(1,2,3)
+      stub.with(3,4,5){ |*args| args.join(":") }
+      assert_equal "3:4:5", @myobj.myargs(3,4,5)
+
+      stub = MuchStub::Stub.new(@myobj, :myargs).on_call{ |call| call.args.join(",") }
+      assert_equal "1,2,3", @myobj.myargs(1,2,3)
+      stub.with(3,4,5).on_call{ |call| call.args.join(":") }
+      assert_equal "3:4:5", @myobj.myargs(3,4,5)
     end
 
     should "stub methods with required args and variable args" do
       assert_equal [1,2, [3]], @myobj.myvalargs(1,2,3)
       stub = MuchStub::Stub.new(@myobj, :myvalargs){ |*args| args.join(",") }
       assert_equal "1,2,3", @myobj.myvalargs(1,2,3)
-      assert_equal "3,4,5", @myobj.myvalargs(3,4,5)
-      stub.with(3,4,5){ "three-four-five" }
-      assert_equal "three-four-five", @myobj.myvalargs(3,4,5)
+      stub.with(3,4,5){ |*args| args.join(":") }
+      assert_equal "3:4:5", @myobj.myvalargs(3,4,5)
+
+      stub = MuchStub::Stub.new(@myobj, :myvalargs).on_call{ |call| call.args.join(",") }
+      assert_equal "1,2,3", @myobj.myvalargs(1,2,3)
+      stub.with(3,4,5).on_call{ |call| call.args.join(":") }
+      assert_equal "3:4:5", @myobj.myvalargs(3,4,5)
     end
 
     should "stub methods that yield blocks" do
@@ -325,7 +381,7 @@ module MuchStub
       assert_equal true, blkcalled
     end
 
-    should "store and remove itself on asserts main module" do
+    should "store and remove itself" do
       assert_equal subject, MuchStub.instance_variable_get(subject.ivar_name)
       subject.teardown
       assert_nil MuchStub.instance_variable_get(subject.ivar_name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-stub
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-13 00:00:00.000000000 Z
+date: 2020-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: assert
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.18.0
+        version: 2.18.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.18.0
+        version: 2.18.1
 description: Stubbing API for replacing method calls on objects in test runs.
 email:
 - kelly@kellyredding.com
@@ -38,12 +38,16 @@ files:
 - LICENSE
 - README.md
 - lib/much-stub.rb
+- lib/much-stub/call.rb
+- lib/much-stub/call_spy.rb
 - lib/much-stub/version.rb
 - log/.gitkeep
 - much-stub.gemspec
 - test/helper.rb
 - test/support/factory.rb
 - test/system/much-stub_tests.rb
+- test/unit/call_spy_tests.rb
+- test/unit/call_tests.rb
 - test/unit/much-stub_tests.rb
 - tmp/.gitkeep
 homepage: https://github.com/redding/much-stub
@@ -56,17 +60,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Stubbing API for replacing method calls on objects in test runs.
@@ -74,4 +77,6 @@ test_files:
 - test/helper.rb
 - test/support/factory.rb
 - test/system/much-stub_tests.rb
+- test/unit/call_spy_tests.rb
+- test/unit/call_tests.rb
 - test/unit/much-stub_tests.rb