much-stub 0.1.1 → 0.1.2

data/test/unit/much-stub_tests.rb

@@ -1,16 +1,15 @@
-require 'assert'
-require 'much-stub'
+require "assert"
+require "much-stub"
 
-require 'test/support/factory'
+require "test/support/factory"
 
 module MuchStub
-
   class UnitTests < Assert::Context
     desc "MuchStub"
   end
 
-  class ApiTests < UnitTests
-    desc "api"
+  class APITests < UnitTests
+    desc "API"
     setup do
       @orig_value = Factory.string
       @stub_value = Factory.string
@@ -69,8 +68,8 @@ module MuchStub
 
     should "be able to call a stub's original method" do
       err = assert_raises(NotStubbedError){ MuchStub.stub_send(@myobj, :mymeth) }
-      assert_includes 'not stubbed.',                 err.message
-      assert_includes 'test/unit/much-stub_tests.rb', err.backtrace.first
+      assert_includes "not stubbed.",                 err.message
+      assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
       MuchStub.(@myobj, :mymeth){ @stub_value }
 
@@ -78,13 +77,22 @@ module MuchStub
       assert_equal @orig_value, MuchStub.stub_send(@myobj, :mymeth)
     end
 
+    should "be able to add a stub tap" do
+      my_meth_called_with = nil
+      MuchStub.tap(@myobj, :mymeth){ |value, *args, &block|
+        my_meth_called_with = args
+      }
+
+      assert_equal @orig_value, @myobj.mymeth
+      assert_equal [], my_meth_called_with
+    end
   end
 
   class StubTests < UnitTests
     desc "Stub"
     setup do
       @myclass = Class.new do
-        def mymeth; 'meth'; end
+        def mymeth; "meth"; end
         def myval(val); val; end
         def myargs(*args); args; end
         def myvalargs(val1, val2, *args); [val1, val2, args]; end
@@ -108,7 +116,7 @@ module MuchStub
     end
 
     should "know its names" do
-      assert_equal 'mymeth', subject.method_name
+      assert_equal "mymeth", subject.method_name
       expected = "__muchstub_stub__#{@myobj.object_id}_#{subject.method_name}"
       assert_equal expected, subject.name
       expected = "@__muchstub_stub_#{@myobj.object_id}_" \
@@ -118,23 +126,23 @@ module MuchStub
 
     should "complain when called if no do block was given" do
       err = assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
-      assert_includes 'not stubbed.',                 err.message
-      assert_includes 'test/unit/much-stub_tests.rb', err.backtrace.first
+      assert_includes "not stubbed.",                 err.message
+      assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
-      subject.do = proc{ 'mymeth' }
+      subject.do = proc{ "mymeth" }
       assert_nothing_raised do
         @myobj.mymeth
       end
 
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :mymeth){ 'mymeth' }
+        MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
       end
     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
+      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
@@ -142,20 +150,20 @@ module MuchStub
     end
 
     should "complain if stubbed and called with mismatched arity" do
-      MuchStub::Stub.new(@myobj, :myval){ 'myval' }
+      MuchStub::Stub.new(@myobj, :myval){ "myval" }
       err = assert_raises(MuchStub::StubArityError){ @myobj.myval }
-      assert_includes 'arity mismatch on',       err.message
-      assert_includes 'test/unit/much-stub_tests.rb', err.backtrace.first
+      assert_includes "arity mismatch on",       err.message
+      assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
       assert_nothing_raised { @myobj.myval(1) }
       assert_raises(MuchStub::StubArityError){ @myobj.myval(1,2) }
 
-      MuchStub::Stub.new(@myobj, :myargs){ 'myargs' }
+      MuchStub::Stub.new(@myobj, :myargs){ "myargs" }
       assert_nothing_raised { @myobj.myargs }
       assert_nothing_raised { @myobj.myargs(1) }
       assert_nothing_raised { @myobj.myargs(1,2) }
 
-      MuchStub::Stub.new(@myobj, :myvalargs){ 'myvalargs' }
+      MuchStub::Stub.new(@myobj, :myvalargs){ "myvalargs" }
       assert_raises(MuchStub::StubArityError){ @myobj.myvalargs }
       assert_raises(MuchStub::StubArityError){ @myobj.myvalargs(1) }
       assert_nothing_raised { @myobj.myvalargs(1,2) }
@@ -164,75 +172,75 @@ module MuchStub
 
     should "complain if stubbed with mismatched arity" do
       err = assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myval).with(){ 'myval' }
+        MuchStub::Stub.new(@myobj, :myval).with(){ "myval" }
       end
-      assert_includes 'arity mismatch on',       err.message
-      assert_includes 'test/unit/much-stub_tests.rb', err.backtrace.first
+      assert_includes "arity mismatch on",       err.message
+      assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
       assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myval).with(1,2){ 'myval' }
+        MuchStub::Stub.new(@myobj, :myval).with(1,2){ "myval" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myval).with(1){ 'myval' }
+        MuchStub::Stub.new(@myobj, :myval).with(1){ "myval" }
       end
 
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myargs).with(){ 'myargs' }
+        MuchStub::Stub.new(@myobj, :myargs).with(){ "myargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myargs).with(1,2){ 'myargs' }
+        MuchStub::Stub.new(@myobj, :myargs).with(1,2){ "myargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myargs).with(1){ 'myargs' }
+        MuchStub::Stub.new(@myobj, :myargs).with(1){ "myargs" }
       end
 
       assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(){ 'myvalargs' }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(){ "myvalargs" }
       end
       assert_raises(MuchStub::StubArityError) do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(1){ 'myvalargs' }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(1){ "myvalargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2){ 'myvalargs' }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2){ "myvalargs" }
       end
       assert_nothing_raised do
-        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2,3){ 'myvalargs' }
+        MuchStub::Stub.new(@myobj, :myvalargs).with(1,2,3){ "myvalargs" }
       end
     end
 
     should "stub methods with no args" do
       subject.teardown
 
-      assert_equal 'meth', @myobj.mymeth
-      MuchStub::Stub.new(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', @myobj.mymeth
+      assert_equal "meth", @myobj.mymeth
+      MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
+      assert_equal "mymeth", @myobj.mymeth
     end
 
     should "stub methods with required arg" do
       assert_equal 1, @myobj.myval(1)
       stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
-      assert_equal '1', @myobj.myval(1)
-      assert_equal '2', @myobj.myval(2)
-      stub.with(2){ 'two' }
-      assert_equal 'two', @myobj.myval(2)
+      assert_equal "1", @myobj.myval(1)
+      assert_equal "2", @myobj.myval(2)
+      stub.with(2){ "two" }
+      assert_equal "two", @myobj.myval(2)
     end
 
     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)
+      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)
     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 = 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)
     end
 
     should "stub methods that yield blocks" do
@@ -242,9 +250,9 @@ module MuchStub
       assert_equal true, blkcalled
 
       blkcalled = false
-      MuchStub::Stub.new(@myobj, :myblk){ blkcalled = 'true' }
+      MuchStub::Stub.new(@myobj, :myblk){ blkcalled = "true" }
       @myobj.myblk(&blk)
-      assert_equal 'true', blkcalled
+      assert_equal "true", blkcalled
     end
 
     should "stub methods even if they are not local to the object" do
@@ -263,56 +271,56 @@ module MuchStub
 
       assert_equal [1,2,[3]], mydelegator.myvalargs(1,2,3)
       stub = MuchStub::Stub.new(mydelegator, :myvalargs){ |*args| args.inspect }
-      assert_equal '[1, 2, 3]', mydelegator.myvalargs(1,2,3)
-      assert_equal '[4, 5, 6]', mydelegator.myvalargs(4,5,6)
-      stub.with(4,5,6){ 'four-five-six' }
-      assert_equal 'four-five-six', mydelegator.myvalargs(4,5,6)
+      assert_equal "[1, 2, 3]", mydelegator.myvalargs(1,2,3)
+      assert_equal "[4, 5, 6]", mydelegator.myvalargs(4,5,6)
+      stub.with(4,5,6){ "four-five-six" }
+      assert_equal "four-five-six", mydelegator.myvalargs(4,5,6)
     end
 
     should "call to the original method" do
       subject.teardown
 
       # no args
-      stub = MuchStub::Stub.new(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', stub.call([])
-      assert_equal 'meth',   stub.call_method([])
+      stub = MuchStub::Stub.new(@myobj, :mymeth){ "mymeth" }
+      assert_equal "mymeth", stub.call([])
+      assert_equal "meth",   stub.call_method([])
 
       # static args
       stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
-      assert_equal '1', stub.call([1])
+      assert_equal "1", stub.call([1])
       assert_equal 1,   stub.call_method([1])
-      assert_equal '2', stub.call([2])
+      assert_equal "2", stub.call([2])
       assert_equal 2,   stub.call_method([2])
-      stub.with(2){ 'two' }
-      assert_equal 'two', stub.call([2])
+      stub.with(2){ "two" }
+      assert_equal "two", stub.call([2])
       assert_equal 2,     stub.call_method([2])
 
       # dynamic args
-      stub = MuchStub::Stub.new(@myobj, :myargs){ |*args| args.join(',') }
-      assert_equal '1,2',   stub.call([1,2])
+      stub = MuchStub::Stub.new(@myobj, :myargs){ |*args| args.join(",") }
+      assert_equal "1,2",   stub.call([1,2])
       assert_equal [1,2],   stub.call_method([1,2])
-      assert_equal '3,4,5', stub.call([3,4,5])
+      assert_equal "3,4,5", stub.call([3,4,5])
       assert_equal [3,4,5], stub.call_method([3,4,5])
-      stub.with(3,4,5){ 'three-four-five' }
-      assert_equal 'three-four-five', stub.call([3,4,5])
+      stub.with(3,4,5){ "three-four-five" }
+      assert_equal "three-four-five", stub.call([3,4,5])
       assert_equal [3,4,5],           stub.call_method([3,4,5])
 
       # mixed static/dynamic args
-      stub = MuchStub::Stub.new(@myobj, :myvalargs){ |*args| args.join(',') }
-      assert_equal '1,2,3',    stub.call([1,2,3])
+      stub = MuchStub::Stub.new(@myobj, :myvalargs){ |*args| args.join(",") }
+      assert_equal "1,2,3",    stub.call([1,2,3])
       assert_equal [1,2, [3]], stub.call_method([1,2,3])
-      assert_equal '3,4,5',    stub.call([3,4,5])
+      assert_equal "3,4,5",    stub.call([3,4,5])
       assert_equal [3,4,[5]],  stub.call_method([3,4,5])
-      stub.with(3,4,5){ 'three-four-five' }
-      assert_equal 'three-four-five', stub.call([3,4,5])
+      stub.with(3,4,5){ "three-four-five" }
+      assert_equal "three-four-five", stub.call([3,4,5])
       assert_equal [3,4,[5]],         stub.call_method([3,4,5])
 
       # blocks
       blkcalled = false
       blk = proc{ blkcalled = true }
-      stub = MuchStub::Stub.new(@myobj, :myblk){ blkcalled = 'true' }
+      stub = MuchStub::Stub.new(@myobj, :myblk){ blkcalled = "true" }
       stub.call([], &blk)
-      assert_equal 'true', blkcalled
+      assert_equal "true", blkcalled
       stub.call_method([], &blk)
       assert_equal true, blkcalled
     end
@@ -326,17 +334,16 @@ module MuchStub
     should "be removable" do
       assert_equal 1, @myobj.myval(1)
       stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
-      assert_equal '1', @myobj.myval(1)
+      assert_equal "1", @myobj.myval(1)
       stub.teardown
       assert_equal 1, @myobj.myval(1)
     end
 
     should "have a readable inspect" do
-      expected = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)}" \
+      expected = "#<#{subject.class}:#{"0x0%x" % (subject.object_id << 1)}" \
                  " @method_name=#{subject.method_name.inspect}>"
       assert_equal expected, subject.inspect
     end
-
   end
 
   class MutatingArgsStubTests < StubTests
@@ -354,7 +361,6 @@ module MuchStub
     should "not raise a stub error when called" do
       assert_nothing_raised{ @stub.call([@arg]) }
     end
-
   end
 
   class StubInheritedMethodAfterStubbedOnParentTests < StubTests
@@ -369,11 +375,11 @@ module MuchStub
 
     should "allow stubbing them independently of each other" do
       assert_nothing_raised do
-        @parent_stub.with(1, 2){ 'parent' }
-        @child_stub.with(1, 2){ 'child' }
+        @parent_stub.with(1, 2){ "parent" }
+        @child_stub.with(1, 2){ "child" }
       end
-      assert_equal 'parent', @parent_class.new(1, 2)
-      assert_equal 'child', @child_class.new(1, 2)
+      assert_equal "parent", @parent_class.new(1, 2)
+      assert_equal "child", @child_class.new(1, 2)
     end
 
     should "not raise any errors when tearing down the parent before the child" do
@@ -382,7 +388,6 @@ module MuchStub
         @child_stub.teardown
       end
     end
-
   end
 
   class NullStubTests < UnitTests
@@ -393,7 +398,6 @@ module MuchStub
     subject{ @ns }
 
     should have_imeths :teardown
-
   end
 
   class ParameterListTests < UnitTests
@@ -401,7 +405,7 @@ module MuchStub
     setup do
       many_args = (0..ParameterList::LETTERS.size).map do
         Assert::Factory.string
-      end.join(', ')
+      end.join(", ")
       @object = Class.new
       # use `class_eval` with string to easily define methods with many params
       @object.class_eval <<-methods
@@ -414,23 +418,22 @@ module MuchStub
     subject{ ParameterList }
 
     should "build a parameter list for a method that takes no args" do
-      assert_equal '&block', subject.new(@object, 'noargs')
+      assert_equal "&block", subject.new(@object, "noargs")
     end
 
     should "build a parameter list for a method that takes any args" do
-      assert_equal '*args, &block', subject.new(@object, 'anyargs')
+      assert_equal "*args, &block", subject.new(@object, "anyargs")
     end
 
     should "build a parameter list for a method that takes many args" do
-      expected = "#{ParameterList::LETTERS.join(', ')}, aa, &block"
-      assert_equal expected, subject.new(@object, 'manyargs')
+      expected = "#{ParameterList::LETTERS.join(", ")}, aa, &block"
+      assert_equal expected, subject.new(@object, "manyargs")
     end
 
     should "build a parameter list for a method that takes a minimum number of args" do
-      expected = "#{ParameterList::LETTERS.join(', ')}, aa, *args, &block"
-      assert_equal expected, subject.new(@object, 'minargs')
+      expected = "#{ParameterList::LETTERS.join(", ")}, aa, *args, &block"
+      assert_equal expected, subject.new(@object, "minargs")
     end
-
   end
 
   class ChangeHashObject
@@ -446,5 +449,4 @@ module MuchStub
       @value = 1
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-stub
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2020-01-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.17.0
+        version: 2.18.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.17.0
+        version: 2.18.0
 description: Stubbing API for replacing method calls on objects in test runs.
 email:
 - kelly@kellyredding.com
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Stubbing API for replacing method calls on objects in test runs.