much-stub 0.1.6 → 0.1.7

data/test/unit/call_spy_tests.rb

@@ -75,7 +75,8 @@ class MuchStub::CallSpy
     end
     subject{ @spy }
 
-    should "return the given values instead of itself if that method is called" do
+    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
@@ -87,7 +88,7 @@ class MuchStub::CallSpy
     desc "when init with return value procs"
     setup do
       @result = Factory.boolean
-      @spy = @unit_class.new(any?: ->(call) { @result })
+      @spy = @unit_class.new(any?: ->(_call){ @result })
     end
     subject{ @spy }
 

data/test/unit/call_tests.rb

@@ -14,9 +14,9 @@ class MuchStub::Call
       @pargs = [Factory.string, Factory.integer]
       @kargs = {
         one: 1,
-        two: 2
+        two: 2,
       }
-      @block = -> {}
+      @block = ->{}
     end
   end
 

data/test/unit/much-stub_tests.rb

@@ -17,14 +17,19 @@ 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.stub(@myobj, :mymeth)
@@ -34,9 +39,9 @@ module MuchStub
     should "build a stub with an on_call block" do
       my_meth_called_with = nil
       stub1 =
-        MuchStub.on_call(@myobj, :mymeth) { |call|
+        MuchStub.on_call(@myobj, :mymeth) do |call|
           my_meth_called_with = call
-        }
+        end
 
       @myobj.mymeth
       assert_kind_of MuchStub::Stub, stub1
@@ -44,9 +49,9 @@ module MuchStub
 
       my_meth_called_with = nil
       stub2 =
-        MuchStub.stub_on_call(@myobj, :mymeth) { |call|
+        MuchStub.stub_on_call(@myobj, :mymeth) do |call|
           my_meth_called_with = call
-        }
+        end
 
       @myobj.mymeth
       assert_kind_of MuchStub::Stub, stub2
@@ -54,15 +59,15 @@ module MuchStub
     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
 
@@ -72,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
@@ -81,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
 
@@ -91,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)
@@ -103,9 +111,9 @@ 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
@@ -113,9 +121,9 @@ module MuchStub
 
     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|
+      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
@@ -123,10 +131,21 @@ module MuchStub
 
     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
+        def one
+          self
+        end
+
+        def two(_val)
+          self
+        end
+
+        def three
+          self
+        end
+
+        def ready?
+          false
+        end
       end
       myobj = myclass.new
 
@@ -137,7 +156,8 @@ module MuchStub
           :two,
           :three,
           :to_s,
-          ready?: true)
+          ready?: true,
+        )
 
       assert_equal spy, myobj.one
       assert_equal spy, myobj.two("a")
@@ -161,11 +181,25 @@ module MuchStub
     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
 
@@ -181,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
@@ -218,67 +255,70 @@ module MuchStub
     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
+      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
 
@@ -292,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" }
@@ -300,30 +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,3", @myobj.myargs(1,2,3)
-      stub.with(3,4,5){ |*args| args.join(":") }
-      assert_equal "3:4:5", @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)
+      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)
-      stub.with(3,4,5){ |*args| args.join(":") }
-      assert_equal "3:4:5", @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{ |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)
+      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
@@ -343,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
@@ -369,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])
@@ -380,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
@@ -416,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
 
@@ -465,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
@@ -486,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
@@ -513,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