much-stub 0.1.2 → 0.1.7

data/test/unit/call_spy_tests.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+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_true 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
+
+  class InitWithNilReturnValuesTests < UnitTests
+    desc "when init with nil return values"
+    setup do
+      @spy = @unit_class.new(result: nil)
+    end
+    subject{ @spy }
+
+    should "return nil" do
+      assert_equal "nil", subject.get.set!("value1").result.inspect
+    end
+  end
+end

data/test/unit/call_tests.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "much-stub"
 
@@ -15,30 +17,57 @@ module MuchStub
       @stub_value = Factory.string
 
       @myclass = Class.new do
-        def initialize(value); @value = value; end
-        def mymeth; @value; end
+        def initialize(value)
+          @value = value
+        end
+
+        def mymeth
+          @value
+        end
       end
       @myobj = @myclass.new(@orig_value)
     end
 
     should "build a stub" do
-      stub1 = MuchStub.(@myobj, :mymeth)
+      stub1 = MuchStub.call(@myobj, :mymeth)
       assert_kind_of MuchStub::Stub, stub1
 
-      stub2 = MuchStub.call(@myobj, :mymeth)
+      stub2 = MuchStub.stub(@myobj, :mymeth)
+      assert_kind_of MuchStub::Stub, stub2
+    end
+
+    should "build a stub with an on_call block" do
+      my_meth_called_with = nil
+      stub1 =
+        MuchStub.on_call(@myobj, :mymeth) do |call|
+          my_meth_called_with = call
+        end
+
+      @myobj.mymeth
+      assert_kind_of MuchStub::Stub, stub1
+      assert_equal [], my_meth_called_with.args
+
+      my_meth_called_with = nil
+      stub2 =
+        MuchStub.stub_on_call(@myobj, :mymeth) do |call|
+          my_meth_called_with = call
+        end
+
+      @myobj.mymeth
       assert_kind_of MuchStub::Stub, stub2
+      assert_equal [], my_meth_called_with.args
     end
 
     should "lookup stubs that have been called before" do
-      stub1 = MuchStub.(@myobj, :mymeth)
-      stub2 = MuchStub.(@myobj, :mymeth)
+      stub1 = MuchStub.call(@myobj, :mymeth)
+      stub2 = MuchStub.call(@myobj, :mymeth)
       assert_same stub1, stub2
     end
 
     should "set the stub's do block if given a block" do
-      MuchStub.(@myobj, :mymeth)
+      MuchStub.call(@myobj, :mymeth)
       assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
     end
 
@@ -48,7 +77,7 @@ module MuchStub
       assert_equal @orig_value, @myobj.mymeth
 
       assert_equal @orig_value, @myobj.mymeth
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
       MuchStub.unstub(@myobj, :mymeth)
       assert_equal @orig_value, @myobj.mymeth
@@ -57,7 +86,7 @@ module MuchStub
     should "know and teardown all stubs" do
       assert_equal @orig_value, @myobj.mymeth
 
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
       assert_equal 1, MuchStub.stubs.size
 
@@ -67,11 +96,14 @@ module MuchStub
     end
 
     should "be able to call a stub's original method" do
-      err = assert_raises(NotStubbedError){ MuchStub.stub_send(@myobj, :mymeth) }
+      err =
+        assert_raises(NotStubbedError) do
+          MuchStub.stub_send(@myobj, :mymeth)
+        end
       assert_includes "not stubbed.",                 err.message
       assert_includes "test/unit/much-stub_tests.rb", err.backtrace.first
 
-      MuchStub.(@myobj, :mymeth){ @stub_value }
+      MuchStub.call(@myobj, :mymeth){ @stub_value }
 
       assert_equal @stub_value, @myobj.mymeth
       assert_equal @orig_value, MuchStub.stub_send(@myobj, :mymeth)
@@ -79,24 +111,95 @@ module MuchStub
 
     should "be able to add a stub tap" do
       my_meth_called_with = nil
-      MuchStub.tap(@myobj, :mymeth){ |value, *args, &block|
+      MuchStub.tap(@myobj, :mymeth) do |_value, *args|
         my_meth_called_with = args
-      }
+      end
 
       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) do |_value, call|
+        my_meth_called_with = call
+      end
+
+      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,
+          :to_s,
+          ready?: true,
+        )
+
+      assert_equal spy, myobj.one
+      assert_equal spy, myobj.two("a")
+      assert_equal spy, myobj.three
+      assert_equal spy, myobj.to_s
+
+      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.to_s_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
     desc "Stub"
     setup do
       @myclass = Class.new do
-        def mymeth; "meth"; end
-        def myval(val); val; end
-        def myargs(*args); args; end
-        def myvalargs(val1, val2, *args); [val1, val2, args]; end
-        def myblk(&block); block.call; end
+        def mymeth
+          "meth"
+        end
+
+        def myval(val)
+          val
+        end
+
+        def myargs(*args)
+          args
+        end
+
+        def myvalargs(val1, val2, *args)
+          [val1, val2, args]
+        end
+
+        def myblk(&block)
+          block.call
+        end
       end
       @myobj = @myclass.new
 
@@ -112,7 +215,10 @@ module MuchStub
     should "generate a key given an object and method name" do
       obj = @myobj
       meth = :mymeth
-      assert_equal "--#{obj.object_id}--#{meth}--", MuchStub::Stub.key(obj, meth)
+      assert_equal(
+        "--#{obj.object_id}--#{meth}--",
+        MuchStub::Stub.key(obj, meth),
+      )
     end
 
     should "know its names" do
@@ -134,77 +240,85 @@ 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 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
+    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 stubbed and called with no `do` proc given" do
-      assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
+    should "complain if stubbing a method that the object doesn't respond to" do
+      err =
+        assert_raises(MuchStub::StubError) do
+          MuchStub::Stub.new(@myobj, :some_other_meth)
+        end
+      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 mismatched arity" do
       MuchStub::Stub.new(@myobj, :myval){ "myval" }
       err = assert_raises(MuchStub::StubArityError){ @myobj.myval }
-      assert_includes "arity mismatch on",       err.message
+      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) }
+      assert_nothing_raised{ @myobj.myval(1) }
+      assert_raises(MuchStub::StubArityError){ @myobj.myval(1, 2) }
 
       MuchStub::Stub.new(@myobj, :myargs){ "myargs" }
-      assert_nothing_raised { @myobj.myargs }
-      assert_nothing_raised { @myobj.myargs(1) }
-      assert_nothing_raised { @myobj.myargs(1,2) }
+      assert_nothing_raised{ @myobj.myargs }
+      assert_nothing_raised{ @myobj.myargs(1) }
+      assert_nothing_raised{ @myobj.myargs(1, 2) }
 
       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) }
-      assert_nothing_raised { @myobj.myvalargs(1,2,3) }
+      assert_nothing_raised{ @myobj.myvalargs(1, 2) }
+      assert_nothing_raised{ @myobj.myvalargs(1, 2, 3) }
     end
 
     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 "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" }
       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" }
       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" }
       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
 
@@ -218,7 +332,7 @@ module MuchStub
 
     should "stub methods with required arg" do
       assert_equal 1, @myobj.myval(1)
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
       assert_equal "1", @myobj.myval(1)
       assert_equal "2", @myobj.myval(2)
       stub.with(2){ "two" }
@@ -226,21 +340,36 @@ module MuchStub
     end
 
     should "stub methods with variable args" do
-      assert_equal [1,2], @myobj.myargs(1,2)
+      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 do |call|
+          call.args.join(",")
+        end
+      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)
+      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)
+      assert_equal "1,2,3", @myobj.myvalargs(1, 2, 3)
+      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 do |call|
+          call.args.join(",")
+        end
+      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
@@ -260,21 +389,27 @@ module MuchStub
         def initialize(delegateclass)
           @delegate = delegateclass.new
         end
+
         def respond_to?(meth)
           @delegate.respond_to?(meth) || super
         end
+
         def method_missing(meth, *args, &block)
           respond_to?(meth) ? @delegate.send(meth, *args, &block) : super
         end
+
+        def respond_to_missing?(meth, _)
+          respond_to?(meth) || super
+        end
       end
       mydelegator = mydelegatorclass.new(@myclass)
 
-      assert_equal [1,2,[3]], mydelegator.myvalargs(1,2,3)
+      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
@@ -286,7 +421,7 @@ module MuchStub
       assert_equal "meth",   stub.call_method([])
 
       # static args
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
       assert_equal "1", stub.call([1])
       assert_equal 1,   stub.call_method([1])
       assert_equal "2", stub.call([2])
@@ -297,23 +432,23 @@ module MuchStub
 
       # dynamic args
       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_method([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])
+      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_method([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])
-      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_method([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])
+      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_method([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
@@ -325,7 +460,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)
@@ -333,16 +468,17 @@ module MuchStub
 
     should "be removable" do
       assert_equal 1, @myobj.myval(1)
-      stub = MuchStub::Stub.new(@myobj, :myval){ |val| val.to_s }
+      stub = MuchStub::Stub.new(@myobj, :myval, &:to_s)
       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)}" \
-                 " @method_name=#{subject.method_name.inspect}>"
-      assert_equal expected, subject.inspect
+      exp =
+        "#<#{subject.class}:#{format("0x0%x", (subject.object_id << 1))}" \
+        " @method_name=#{subject.method_name.inspect}>"
+      assert_equal exp, subject.inspect
     end
   end
 
@@ -382,7 +518,8 @@ module MuchStub
       assert_equal "child", @child_class.new(1, 2)
     end
 
-    should "not raise any errors when tearing down the parent before the child" do
+    should "not raise any errors when tearing down the parent before the "\
+           "child" do
       assert_nothing_raised do
         @parent_stub.teardown
         @child_stub.teardown
@@ -403,9 +540,9 @@ module MuchStub
   class ParameterListTests < UnitTests
     desc "ParameterList"
     setup do
-      many_args = (0..ParameterList::LETTERS.size).map do
+      many_args = (0..ParameterList::LETTERS.size).map{
         Assert::Factory.string
-      end.join(", ")
+      }.join(", ")
       @object = Class.new
       # use `class_eval` with string to easily define methods with many params
       @object.class_eval <<-methods
@@ -430,7 +567,8 @@ module MuchStub
       assert_equal expected, subject.new(@object, "manyargs")
     end
 
-    should "build a parameter list for a method that takes a minimum number of args" do
+    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")
     end