much-stub 0.1.1 → 0.1.6

data/test/unit/call_spy_tests.rb

@@ -0,0 +1,110 @@
+# 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,16 +1,17 @@
-require 'assert'
-require 'much-stub'
+# frozen_string_literal: true
 
-require 'test/support/factory'
+require "assert"
+require "much-stub"
 
-module MuchStub
+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
@@ -26,8 +27,30 @@ module MuchStub
       stub1 = MuchStub.(@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) { |call|
+          my_meth_called_with = call
+        }
+
+      @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) { |call|
+          my_meth_called_with = call
+        }
+
+      @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
@@ -69,8 +92,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 +101,67 @@ 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
+
+    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,
+          :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 mymeth; "meth"; end
         def myval(val); val; end
         def myargs(*args); args; end
         def myvalargs(val1, val2, *args); [val1, val2, args]; end
@@ -108,7 +185,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,44 +195,49 @@ 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
 
+      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
-      assert_includes 'test/unit/much-stub_tests.rb', err.backtrace.first
+    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){ 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 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 +246,84 @@ 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,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 = 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)
+
+      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
@@ -242,9 +333,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,61 +354,61 @@ 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
 
-    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)
@@ -326,17 +417,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 +444,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 +458,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 +471,6 @@ module MuchStub
         @child_stub.teardown
       end
     end
-
   end
 
   class NullStubTests < UnitTests
@@ -393,7 +481,6 @@ module MuchStub
     subject{ @ns }
 
     should have_imeths :teardown
-
   end
 
   class ParameterListTests < UnitTests
@@ -401,7 +488,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 +501,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 +532,4 @@ module MuchStub
       @value = 1
     end
   end
-
 end