assert 2.12.1 → 2.12.2

data/lib/assert/stub.rb

@@ -32,12 +32,14 @@ module Assert
       "--#{object.object_id}--#{method_name}--"
     end
 
-    attr_reader :method_name, :name, :do
+    attr_reader :method_name, :name, :ivar_name, :do
 
     def initialize(object, method_name, &block)
       @metaclass = class << object; self; end
       @method_name = method_name.to_s
-      @name = "__assert_stub__#{@method_name}"
+      @name = "__assert_stub__#{object.object_id}_#{@method_name}"
+      @ivar_name = "@__assert_stub_#{object.object_id}_" \
+                   "#{@method_name.to_sym.object_id}"
 
       setup(object)
 
@@ -52,7 +54,12 @@ module Assert
     end
 
     def call(*args, &block)
-      raise StubArityError, "artiy mismatch" unless arity_matches?(args)
+      unless arity_matches?(args)
+        message = "arity mismatch on `#{@method_name}`: " \
+                  "expected #{number_of_args(@method.arity)}, " \
+                  "called with #{args.size}"
+        raise StubArityError, message
+      end
       @lookup[args].call(*args, &block)
     rescue NotStubbedError => exception
       @lookup.rehash
@@ -60,7 +67,12 @@ module Assert
     end
 
     def with(*args, &block)
-      raise StubArityError, "artiy mismatch" unless arity_matches?(args)
+      unless arity_matches?(args)
+        message = "arity mismatch on `#{@method_name}`: " \
+                  "expected #{number_of_args(@method.arity)}, " \
+                  "stubbed with #{args.size}"
+        raise StubArityError, message
+      end
       @lookup[args] = block
     end
 
@@ -70,33 +82,45 @@ module Assert
 
     def teardown
       @metaclass.send(:undef_method, @method_name)
+      Assert.send(:remove_instance_variable, @ivar_name)
       @metaclass.send(:alias_method, @method_name, @name)
       @metaclass.send(:undef_method, @name)
     end
 
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)}" \
+      " @method_name=#{@method_name.inspect}" \
+      ">"
+    end
+
     protected
 
     def setup(object)
       unless object.respond_to?(@method_name)
         raise StubError, "#{object.inspect} does not respond to `#{@method_name}`"
       end
-      if !object.methods.map(&:to_s).include?(@method_name)
+      is_constant = object.kind_of?(Module)
+      local_object_methods = object.methods(false).map(&:to_s)
+      all_object_methods = object.methods.map(&:to_s)
+      if (is_constant && !local_object_methods.include?(@method_name)) ||
+         (!is_constant && !all_object_methods.include?(@method_name))
+        params_list = ParameterList.new(object, @method_name)
         @metaclass.class_eval <<-method
-          def #{@method_name}(*args, &block)
-            super(*args, &block)
-          end
+          def #{@method_name}(#{params_list}); super; end
         method
       end
 
-      if !object.respond_to?(@name) # already stubbed
+      if !local_object_methods.include?(@name) # already stubbed
         @metaclass.send(:alias_method, @name, @method_name)
       end
       @method = object.method(@name)
 
-      stub = self
-      @metaclass.send(:define_method, @method_name) do |*args, &block|
-        stub.call(*args, &block)
-      end
+      Assert.instance_variable_set(@ivar_name, self)
+      @metaclass.class_eval <<-stub_method
+        def #{@method_name}(*args, &block)
+          Assert.instance_variable_get("#{@ivar_name}").call(*args, &block)
+        end
+      stub_method
     end
 
     private
@@ -115,6 +139,45 @@ module Assert
       "`#{@method_name}(#{args.map(&:inspect).join(',')})`"
     end
 
+    def number_of_args(arity)
+      if arity < 0
+        "at least #{(arity + 1).abs}"
+      else
+        arity
+      end
+    end
+
+    module ParameterList
+      LETTERS = ('a'..'z').to_a.freeze
+
+      def self.new(object, method_name)
+        arity = get_arity(object, method_name)
+        params = build_params_from_arity(arity)
+        params << '*args' if arity < 0
+        params << '&block'
+        params.join(', ')
+      end
+
+      private
+
+      def self.get_arity(object, method_name)
+        object.method(method_name).arity
+      rescue NameError
+        -1
+      end
+
+      def self.build_params_from_arity(arity)
+        number = arity < 0 ? (arity + 1).abs : arity
+        (0..(number - 1)).map{ |param_index| get_param_name(param_index) }
+      end
+
+      def self.get_param_name(param_index)
+        param_index += LETTERS.size # avoid getting 0 for the number of letters
+        number_of_letters, letter_index = param_index.divmod(LETTERS.size)
+        LETTERS[letter_index] * number_of_letters
+      end
+    end
+
   end
 
 end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.12.1"
+  VERSION = "2.12.2"
 end

data/test/system/stub_tests.rb

@@ -0,0 +1,754 @@
+require 'assert'
+require 'assert/stub'
+
+class Assert::Stub
+
+  class SystemTests < Assert::Context
+    desc "Assert::Stub"
+
+  end
+
+  class InstanceTests < SystemTests
+    desc "for instance methods"
+    setup do
+      @instance = TestClass.new
+      Assert.stub(@instance, :noargs){ 'default' }
+      Assert.stub(@instance, :noargs).with{ 'none' }
+
+      Assert.stub(@instance, :withargs){ 'default' }
+      Assert.stub(@instance, :withargs).with(1){ 'one' }
+
+      Assert.stub(@instance, :anyargs){ 'default' }
+      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@instance, :minargs){ 'default' }
+      Assert.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@instance, :withblock){ 'default' }
+    end
+    subject{ @instance }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class ClassTests < SystemTests
+    desc "for singleton methods on a class"
+    setup do
+      @class = TestClass
+      Assert.stub(@class, :noargs){ 'default' }
+      Assert.stub(@class, :noargs).with{ 'none' }
+
+      Assert.stub(@class, :withargs){ 'default' }
+      Assert.stub(@class, :withargs).with(1){ 'one' }
+
+      Assert.stub(@class, :anyargs){ 'default' }
+      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@class, :minargs){ 'default' }
+      Assert.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@class, :withblock){ 'default' }
+    end
+    subject{ @class }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class ModuleTests < SystemTests
+    desc "for singleton methods on a module"
+    setup do
+      @module = TestModule
+      Assert.stub(@module, :noargs){ 'default' }
+      Assert.stub(@module, :noargs).with{ 'none' }
+
+      Assert.stub(@module, :withargs){ 'default' }
+      Assert.stub(@module, :withargs).with(1){ 'one' }
+
+      Assert.stub(@module, :anyargs){ 'default' }
+      Assert.stub(@module, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@module, :minargs){ 'default' }
+      Assert.stub(@module, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@module, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@module, :withblock){ 'default' }
+    end
+    subject{ @module }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class ExtendedTests < SystemTests
+    desc "for extended methods"
+    setup do
+      @class = Class.new{ extend TestMixin }
+      Assert.stub(@class, :noargs){ 'default' }
+      Assert.stub(@class, :noargs).with{ 'none' }
+
+      Assert.stub(@class, :withargs){ 'default' }
+      Assert.stub(@class, :withargs).with(1){ 'one' }
+
+      Assert.stub(@class, :anyargs){ 'default' }
+      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@class, :minargs){ 'default' }
+      Assert.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@class, :withblock){ 'default' }
+    end
+    subject{ @class }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class IncludedTests < SystemTests
+    desc "for an included method"
+    setup do
+      @class = Class.new{ include TestMixin }
+      @instance = @class.new
+      Assert.stub(@instance, :noargs){ 'default' }
+      Assert.stub(@instance, :noargs).with{ 'none' }
+
+      Assert.stub(@instance, :withargs){ 'default' }
+      Assert.stub(@instance, :withargs).with(1){ 'one' }
+
+      Assert.stub(@instance, :anyargs){ 'default' }
+      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@instance, :minargs){ 'default' }
+      Assert.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@instance, :withblock){ 'default' }
+    end
+    subject{ @instance }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class InheritedClassTests < SystemTests
+    desc "for an inherited class method"
+    setup do
+      @class = Class.new(TestClass)
+      Assert.stub(@class, :noargs){ 'default' }
+      Assert.stub(@class, :noargs).with{ 'none' }
+
+      Assert.stub(@class, :withargs){ 'default' }
+      Assert.stub(@class, :withargs).with(1){ 'one' }
+
+      Assert.stub(@class, :anyargs){ 'default' }
+      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@class, :minargs){ 'default' }
+      Assert.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@class, :withblock){ 'default' }
+    end
+    subject{ @class }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class InheritedInstanceTests < SystemTests
+    desc "for an inherited instance method"
+    setup do
+      @class = Class.new(TestClass)
+      @instance = @class.new
+      Assert.stub(@instance, :noargs){ 'default' }
+      Assert.stub(@instance, :noargs).with{ 'none' }
+
+      Assert.stub(@instance, :withargs){ 'default' }
+      Assert.stub(@instance, :withargs).with(1){ 'one' }
+
+      Assert.stub(@instance, :anyargs){ 'default' }
+      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@instance, :minargs){ 'default' }
+      Assert.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@instance, :withblock){ 'default' }
+    end
+    subject{ @instance }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "not allow stubbing methods with invalid arity" do
+      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withargs).with{ } }
+      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ Assert.stub(subject, :minargs).with{ } }
+      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "not allow calling methods with invalid arity" do
+      assert_raises{ subject.noargs(1) }
+
+      assert_raises{ subject.withargs }
+      assert_raises{ subject.withargs(1, 2) }
+
+      assert_raises{ subject.minargs }
+      assert_raises{ subject.minargs(1) }
+
+      assert_raises{ subject.withblock(1) }
+    end
+
+  end
+
+  class DelegateClassTests < SystemTests
+    desc "a class that delegates another object"
+    setup do
+      @class = DelegateClass
+      Assert.stub(@class, :noargs){ 'default' }
+      Assert.stub(@class, :noargs).with{ 'none' }
+
+      Assert.stub(@class, :withargs){ 'default' }
+      Assert.stub(@class, :withargs).with(1){ 'one' }
+
+      Assert.stub(@class, :anyargs){ 'default' }
+      Assert.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@class, :minargs){ 'default' }
+      Assert.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@class, :withblock){ 'default' }
+    end
+    subject{ @class }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "allow stubbing methods with invalid arity" do
+      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
+      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
+      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "allow calling methods with invalid arity" do
+      assert_nothing_raised{ subject.noargs(1) }
+
+      assert_nothing_raised{ subject.withargs }
+      assert_nothing_raised{ subject.withargs(1, 2) }
+
+      assert_nothing_raised{ subject.minargs }
+      assert_nothing_raised{ subject.minargs(1) }
+
+      assert_nothing_raised{ subject.withblock(1) }
+    end
+
+  end
+
+  class DelegateInstanceTests < SystemTests
+    desc "an instance that delegates another object"
+    setup do
+      @instance = DelegateClass.new
+      Assert.stub(@instance, :noargs){ 'default' }
+      Assert.stub(@instance, :noargs).with{ 'none' }
+
+      Assert.stub(@instance, :withargs){ 'default' }
+      Assert.stub(@instance, :withargs).with(1){ 'one' }
+
+      Assert.stub(@instance, :anyargs){ 'default' }
+      Assert.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      Assert.stub(@instance, :minargs){ 'default' }
+      Assert.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      Assert.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      Assert.stub(@instance, :withblock){ 'default' }
+    end
+    subject{ @instance }
+
+    should "allow stubbing a method that doesn't take args" do
+      assert_equal 'none', subject.noargs
+    end
+
+    should "allow stubbing a method that takes args" do
+      assert_equal 'one',     subject.withargs(1)
+      assert_equal 'default', subject.withargs(2)
+    end
+
+    should "allow stubbing a method that takes any args" do
+      assert_equal 'default', subject.anyargs
+      assert_equal 'default', subject.anyargs(1)
+      assert_equal 'one-two', subject.anyargs(1, 2)
+    end
+
+    should "allow stubbing a method that takes a minimum number of args" do
+      assert_equal 'one-two',       subject.minargs(1, 2)
+      assert_equal 'one-two-three', subject.minargs(1, 2, 3)
+      assert_equal 'default',       subject.minargs(1, 2, 4)
+      assert_equal 'default',       subject.minargs(1, 2, 3, 4)
+    end
+
+    should "allow stubbing a method that takes a block" do
+      assert_equal 'default', subject.withblock
+      assert_equal 'default', subject.withblock{ 'my-block' }
+    end
+
+    should "allow stubbing methods with invalid arity" do
+      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
+      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
+      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+
+      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+    end
+
+    should "allow calling methods with invalid arity" do
+      assert_nothing_raised{ subject.noargs(1) }
+
+      assert_nothing_raised{ subject.withargs }
+      assert_nothing_raised{ subject.withargs(1, 2) }
+
+      assert_nothing_raised{ subject.minargs }
+      assert_nothing_raised{ subject.minargs(1) }
+
+      assert_nothing_raised{ subject.withblock(1) }
+    end
+
+  end
+
+  class ParentAndChildClassTests < SystemTests
+    desc "for a parent method stubbed on both the parent and child"
+    setup do
+      @parent_class = Class.new
+      @child_class = Class.new(@parent_class)
+
+      Assert.stub(@parent_class, :new){ 'parent' }
+      Assert.stub(@child_class, :new){ 'child' }
+    end
+
+    should "allow stubbing the methods individually" do
+      assert_equal 'parent', @parent_class.new
+      assert_equal 'child', @child_class.new
+    end
+
+  end
+
+  class TestClass
+
+    def self.noargs; end
+    def self.withargs(a); end
+    def self.anyargs(*args); end
+    def self.minargs(a, b, *args); end
+    def self.withblock(&block); end
+
+    def noargs; end
+    def withargs(a); end
+    def anyargs(*args); end
+    def minargs(a, b, *args); end
+    def withblock(&block); end
+
+  end
+
+  module TestModule
+
+    def self.noargs; end
+    def self.withargs(a); end
+    def self.anyargs(*args); end
+    def self.minargs(a, b, *args); end
+    def self.withblock(&block); end
+
+  end
+
+  module TestMixin
+
+    def noargs; end
+    def withargs(a); end
+    def anyargs(*args); end
+    def minargs(a, b, *args); end
+    def withblock(&block); end
+
+  end
+
+  class DelegateClass
+    def self.respond_to?(*args)
+      TestClass.respond_to?(*args) || super
+    end
+
+    def self.method_missing(name, *args, &block)
+      TestClass.respond_to?(name) ? TestClass.send(name, *args, &block) : super
+    end
+
+    def initialize
+      @delegate = TestClass.new
+    end
+
+    def respond_to?(*args)
+      @delegate.respond_to?(*args) || super
+    end
+
+    def method_missing(name, *args, &block)
+      @delegate.respond_to?(name) ? @delegate.send(name, *args, &block) : super
+    end
+  end
+
+end

data/test/unit/stub_tests.rb

@@ -1,6 +1,8 @@
 require 'assert'
 require 'assert/stub'
 
+require 'assert/factory'
+
 class Assert::Stub
 
   class UnitTests < Assert::Context
@@ -19,7 +21,7 @@ class Assert::Stub
     end
     subject{ @stub }
 
-    should have_readers :method_name, :name, :do
+    should have_readers :method_name, :name, :ivar_name, :do
     should have_writers :do
     should have_cmeths :key
 
@@ -31,7 +33,11 @@ class Assert::Stub
 
     should "know its names" do
       assert_equal 'mymeth', subject.method_name
-      assert_equal "__assert_stub__#{subject.method_name}", subject.name
+      expected = "__assert_stub__#{@myobj.object_id}_#{subject.method_name}"
+      assert_equal expected, subject.name
+      expected = "@__assert_stub_#{@myobj.object_id}_" \
+                 "#{subject.method_name.to_sym.object_id}"
+      assert_equal expected, subject.ivar_name
     end
 
     should "complain when called if no do block was given" do
@@ -181,6 +187,12 @@ class Assert::Stub
       assert_equal 'four-five-six', mydelegator.myvalargs(4,5,6)
     end
 
+    should "store and remove itself on asserts main module" do
+      assert_equal subject, Assert.instance_variable_get(subject.ivar_name)
+      subject.teardown
+      assert_nil Assert.instance_variable_get(subject.ivar_name)
+    end
+
     should "be removable" do
       assert_equal 1, @myobj.myval(1)
       stub = Assert::Stub.new(@myobj, :myval){ |val| val.to_s }
@@ -189,6 +201,12 @@ class Assert::Stub
       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
+    end
+
   end
 
   class MutatingArgsStubTests < UnitTests
@@ -209,6 +227,34 @@ class Assert::Stub
 
   end
 
+  class StubInheritedMethodAfterStubbedOnParentTests < UnitTests
+    desc "stubbing an inherited method after its stubbed on the parent class"
+    setup do
+      @parent_class = Class.new
+      @child_class = Class.new(@parent_class)
+
+      @parent_stub = Assert::Stub.new(@parent_class, :new)
+      @child_stub = Assert::Stub.new(@child_class, :new)
+    end
+
+    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' }
+      end
+      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
+      assert_nothing_raised do
+        @parent_stub.teardown
+        @child_stub.teardown
+      end
+    end
+
+  end
+
   class NullStubTests < UnitTests
     desc "NullStub"
     setup do
@@ -220,6 +266,43 @@ class Assert::Stub
 
   end
 
+  class ParameterListTests < UnitTests
+    desc "ParameterList"
+    setup do
+      many_args = (0..ParameterList::LETTERS.size).map do
+        Assert::Factory.string
+      end.join(', ')
+      @object = Class.new
+      # use `class_eval` with string to easily define methods with many params
+      @object.class_eval <<-methods
+        def self.noargs; end
+        def self.anyargs(*args); end
+        def self.manyargs(#{many_args}); end
+        def self.minargs(#{many_args}, *args); end
+      methods
+    end
+    subject{ ParameterList }
+
+    should "build a parameter list for a method that takes no args" do
+      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')
+    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')
+    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')
+    end
+
+  end
+
   class ChangeHashObject
     def initialize
       @value = nil

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  hash: 61
+  hash: 59
   prerelease: 
   segments: 
   - 2
   - 12
-  - 1
-  version: 2.12.1
+  - 2
+  version: 2.12.2
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-06-27 00:00:00 Z
+date: 2014-07-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -84,6 +84,7 @@ files:
 - test/support/factory.rb
 - test/support/inherited_stuff.rb
 - test/system/running_tests.rb
+- test/system/stub_tests.rb
 - test/unit/assert_tests.rb
 - test/unit/assertions/assert_block_tests.rb
 - test/unit/assertions/assert_empty_tests.rb
@@ -155,6 +156,7 @@ test_files:
 - test/support/factory.rb
 - test/support/inherited_stuff.rb
 - test/system/running_tests.rb
+- test/system/stub_tests.rb
 - test/unit/assert_tests.rb
 - test/unit/assertions/assert_block_tests.rb
 - test/unit/assertions/assert_empty_tests.rb