much-stub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: e5d7e06636c2654760be8dee2fbe8c80d9b86ef4
+  data.tar.gz: ebca2dede9dd9f9305548d3d8eb9db88a4ec1bae
+SHA512: 
+  metadata.gz: 6e4b733a9dccaa7babf00419d86f7e6d112d1a84cfe306c854509e9109bedbaae1c22f2ed4d83edd95f05c571c9ce804251bd0ca75a790478703bf4a703497d8
+  data.tar.gz: b41abee2b1ed680b2df84d1eb08c5854beb98001a5b774c4ef2311e583200b96cbdb2ccf1872068c98d050107a1e3fc23eecc02e283fe01cb8e211ce2365b875

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.log
+*.rbc
+.rbx/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'pry', "~> 0.9.0"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2018-Present Kelly Redding and Collin Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# MuchStub
+
+MuchStub is a stubbing API for replacing method calls on objects in test runs.  This is intended to be brought into testing environments and used in test runs to stub out external dependencies.
+
+All it does is replace method calls.  In general it tries to be friendly and complain if stubbing doesn't match up with the object/method being stubbed:
+
+* each stub takes a block that is called in place of the method
+* complains if you stub a method that the object doesn't respond to
+* complains if you stub with an arity mismatch
+* no methods are added to `Object` to support stubbing
+
+Note: this was originally implemented in and extracted from [Assert](https://github.com/redding/assert).
+
+## Usage
+
+```ruby
+myclass = Class.new do
+  def mymeth; 'meth'; end
+  def myval(val); val; end
+end
+myobj = myclass.new
+
+myobj.mymeth
+  # => 'meth'
+myobj.myval(123)
+  # => 123
+myobj.myval(456)
+  # => 456
+
+MuchStub.stub(myobj, :mymeth)
+myobj.mymeth
+  # => StubError: `mymeth` not stubbed.
+MuchStub.stub(myobj, :mymeth){ 'stub-meth' }
+myobj.mymeth
+  # => 'stub-meth'
+myobj.mymeth(123)
+  # => StubError: arity mismatch
+MuchStub.stub(myobj, :mymeth).with(123){ 'stub-meth' }
+  # => StubError: arity mismatch
+MuchStub.stub_send(myobj, :mymeth) # call to the original method post-stub
+  # => 'meth'
+
+MuchStub.stub(myobj, :myval){ 'stub-meth' }
+  # => StubError: arity mismatch
+MuchStub.stub(myobj, :myval).with(123){ |val| val.to_s }
+myobj.myval
+  # => StubError: arity mismatch
+myobj.myval(123)
+  # => '123'
+myobj.myval(456)
+  # => StubError: `myval(456)` not stubbed.
+MuchStub.stub_send(myobj, :myval, 123) # call to the original method post-stub
+  # => 123
+MuchStub.stub_send(myobj, :myval, 456)
+  # => 456
+
+MuchStub.unstub(myobj, :mymeth)
+MuchStub.unstub(myobj, :myval)
+
+myobj.mymeth
+  # => 'meth'
+myobj.myval(123)
+  # => 123
+myobj.myval(456)
+  # => 456
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'much-stub'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install much-stub
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/much-stub.rb

@@ -0,0 +1,216 @@
+require "much-stub/version"
+
+module MuchStub
+
+  def self.stubs
+    @stubs ||= {}
+  end
+
+  def self.stub(obj, meth, &block)
+    (self.stubs[MuchStub::Stub.key(obj, meth)] ||= begin
+      MuchStub::Stub.new(obj, meth, caller_locations)
+    end).tap{ |s| s.do = block }
+  end
+
+  def self.unstub(obj, meth)
+    (self.stubs.delete(MuchStub::Stub.key(obj, meth)) || MuchStub::NullStub.new).teardown
+  end
+
+  def self.unstub!
+    self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
+  end
+
+  def self.stub_send(obj, meth, *args, &block)
+    orig_caller = caller_locations
+    stub = self.stubs.fetch(MuchStub::Stub.key(obj, meth)) do
+      raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
+    end
+    stub.call_method(args, &block)
+  end
+
+  class Stub
+
+    def self.key(object, method_name)
+      "--#{object.object_id}--#{method_name}--"
+    end
+
+    attr_reader :method_name, :name, :ivar_name, :do
+
+    def initialize(object, method_name, orig_caller = nil, &block)
+      orig_caller ||= caller_locations
+      @metaclass   = class << object; self; end
+      @method_name = method_name.to_s
+      @name        = "__muchstub_stub__#{object.object_id}_#{@method_name}"
+      @ivar_name   = "@__muchstub_stub_#{object.object_id}_" \
+                     "#{@method_name.to_sym.object_id}"
+
+      setup(object, orig_caller)
+
+      @do     = block
+      @lookup = {}
+    end
+
+    def do=(block)
+      @do = block || @do
+    end
+
+    def call_method(args, &block)
+      @method.call(*args, &block)
+    end
+
+    def call(args, orig_caller = nil, &block)
+      orig_caller ||= caller_locations
+      unless arity_matches?(args)
+        msg = "arity mismatch on `#{@method_name}`: " \
+              "expected #{number_of_args(@method.arity)}, " \
+              "called with #{args.size}"
+        raise StubArityError, msg, orig_caller.map(&:to_s)
+      end
+      lookup(args, orig_caller).call(*args, &block)
+    rescue NotStubbedError => exception
+      @lookup.rehash
+      lookup(args, orig_caller).call(*args, &block)
+    end
+
+    def with(*args, &block)
+      orig_caller = caller_locations
+      unless arity_matches?(args)
+        msg = "arity mismatch on `#{@method_name}`: " \
+              "expected #{number_of_args(@method.arity)}, " \
+              "stubbed with #{args.size}"
+        raise StubArityError, msg, orig_caller.map(&:to_s)
+      end
+      @lookup[args] = block
+    end
+
+    def teardown
+      @metaclass.send(:undef_method, @method_name)
+      MuchStub.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
+
+    private
+
+    def setup(object, orig_caller)
+      unless object.respond_to?(@method_name)
+        msg = "#{object.inspect} does not respond to `#{@method_name}`"
+        raise StubError, msg, orig_caller.map(&:to_s)
+      end
+      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}(#{params_list}); super; end
+        method
+      end
+
+      if !local_object_methods.include?(@name) # already stubbed
+        @metaclass.send(:alias_method, @name, @method_name)
+      end
+      @method = object.method(@name)
+
+      MuchStub.instance_variable_set(@ivar_name, self)
+      @metaclass.class_eval <<-stub_method
+        def #{@method_name}(*args, &block)
+          MuchStub.instance_variable_get("#{@ivar_name}").call(args, caller_locations, &block)
+        end
+      stub_method
+    end
+
+    def lookup(args, orig_caller)
+      @lookup.fetch(args) do
+        self.do || begin
+          msg = "#{inspect_call(args)} not stubbed."
+          inspect_lookup_stubs.tap do |stubs|
+            msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+          end
+          raise NotStubbedError, msg, orig_caller.map(&:to_s)
+        end
+      end
+    end
+
+    def arity_matches?(args)
+      return true if @method.arity == args.size # mandatory args
+      return true if @method.arity < 0 && args.size >= (@method.arity+1).abs # variable args
+      return false
+    end
+
+    def inspect_lookup_stubs
+      @lookup.keys.map{ |args| "    - #{inspect_call(args)}" }.join("\n")
+    end
+
+    def inspect_call(args)
+      "`#{@method_name}(#{args.map(&:inspect).join(',')})`"
+    end
+
+    def number_of_args(arity)
+      if arity < 0
+        "at least #{(arity + 1).abs}"
+      else
+        arity
+      end
+    end
+
+  end
+
+  StubError       = Class.new(ArgumentError)
+  NotStubbedError = Class.new(StubError)
+  StubArityError  = Class.new(StubError)
+
+  NullStub = Class.new do
+    def teardown; end # no-op
+  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
+
+# Kernel#caller_locations polyfill for pre ruby 2.0.0
+if RUBY_VERSION =~ /\A1\..+/ && !Kernel.respond_to?(:caller_locations)
+  module Kernel
+    def caller_locations(start = 1, length = nil)
+      length ? caller[start, length] : caller[start..-1]
+    end
+  end
+end

data/lib/much-stub/version.rb

@@ -0,0 +1,3 @@
+module MuchStub
+  VERSION = "0.1.0"
+end

data/much-stub.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "much-stub/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "much-stub"
+  gem.version     = MuchStub::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.summary     = "Stubbing API for replacing method calls on objects in test runs."
+  gem.description = "Stubbing API for replacing method calls on objects in test runs."
+  gem.homepage    = "https://github.com/redding/much-stub"
+  gem.license     = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert", ["~> 2.16.3"])
+
+end

data/test/helper.rb

@@ -0,0 +1,25 @@
+# this file is automatically required when you run `assert`
+# put any test helpers here
+
+# add the root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+# require pry for debugging (`binding.pry`)
+require 'pry'
+
+require 'test/support/factory'
+
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end
+
+# unstub all test stubs automatically for Assert test suite
+require 'assert'
+class Assert::Context
+  teardown{ MuchStub.unstub! }
+end

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/system/much-stub_tests.rb

@@ -0,0 +1,754 @@
+require 'assert'
+require 'much-stub'
+
+module MuchStub
+
+  class SystemTests < Assert::Context
+    desc "MuchStub"
+
+  end
+
+  class InstanceTests < SystemTests
+    desc "for instance methods"
+    setup do
+      @instance = TestClass.new
+      MuchStub.stub(@instance, :noargs){ 'default' }
+      MuchStub.stub(@instance, :noargs).with{ 'none' }
+
+      MuchStub.stub(@instance, :withargs){ 'default' }
+      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@instance, :anyargs){ 'default' }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@instance, :minargs){ 'default' }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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
+      MuchStub.stub(@class, :noargs){ 'default' }
+      MuchStub.stub(@class, :noargs).with{ 'none' }
+
+      MuchStub.stub(@class, :withargs){ 'default' }
+      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@class, :anyargs){ 'default' }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@class, :minargs){ 'default' }
+      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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
+      MuchStub.stub(@module, :noargs){ 'default' }
+      MuchStub.stub(@module, :noargs).with{ 'none' }
+
+      MuchStub.stub(@module, :withargs){ 'default' }
+      MuchStub.stub(@module, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@module, :anyargs){ 'default' }
+      MuchStub.stub(@module, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@module, :minargs){ 'default' }
+      MuchStub.stub(@module, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@module, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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 }
+      MuchStub.stub(@class, :noargs){ 'default' }
+      MuchStub.stub(@class, :noargs).with{ 'none' }
+
+      MuchStub.stub(@class, :withargs){ 'default' }
+      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@class, :anyargs){ 'default' }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@class, :minargs){ 'default' }
+      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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
+      MuchStub.stub(@instance, :noargs){ 'default' }
+      MuchStub.stub(@instance, :noargs).with{ 'none' }
+
+      MuchStub.stub(@instance, :withargs){ 'default' }
+      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@instance, :anyargs){ 'default' }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@instance, :minargs){ 'default' }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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)
+      MuchStub.stub(@class, :noargs){ 'default' }
+      MuchStub.stub(@class, :noargs).with{ 'none' }
+
+      MuchStub.stub(@class, :withargs){ 'default' }
+      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@class, :anyargs){ 'default' }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@class, :minargs){ 'default' }
+      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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
+      MuchStub.stub(@instance, :noargs){ 'default' }
+      MuchStub.stub(@instance, :noargs).with{ 'none' }
+
+      MuchStub.stub(@instance, :withargs){ 'default' }
+      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@instance, :anyargs){ 'default' }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@instance, :minargs){ 'default' }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_raises{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_raises{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_raises{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_raises{ MuchStub.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
+      MuchStub.stub(@class, :noargs){ 'default' }
+      MuchStub.stub(@class, :noargs).with{ 'none' }
+
+      MuchStub.stub(@class, :withargs){ 'default' }
+      MuchStub.stub(@class, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@class, :anyargs){ 'default' }
+      MuchStub.stub(@class, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@class, :minargs){ 'default' }
+      MuchStub.stub(@class, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@class, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_nothing_raised{ MuchStub.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
+      MuchStub.stub(@instance, :noargs){ 'default' }
+      MuchStub.stub(@instance, :noargs).with{ 'none' }
+
+      MuchStub.stub(@instance, :withargs){ 'default' }
+      MuchStub.stub(@instance, :withargs).with(1){ 'one' }
+
+      MuchStub.stub(@instance, :anyargs){ 'default' }
+      MuchStub.stub(@instance, :anyargs).with(1, 2){ 'one-two' }
+
+      MuchStub.stub(@instance, :minargs){ 'default' }
+      MuchStub.stub(@instance, :minargs).with(1, 2){ 'one-two' }
+      MuchStub.stub(@instance, :minargs).with(1, 2, 3){ 'one-two-three' }
+
+      MuchStub.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{ MuchStub.stub(subject, :noargs).with(1){ } }
+
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with{ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :withargs).with(1, 2){ } }
+
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with{ } }
+      assert_nothing_raised{ MuchStub.stub(subject, :minargs).with(1){ } }
+
+      assert_nothing_raised{ MuchStub.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)
+
+      MuchStub.stub(@parent_class, :new){ 'parent' }
+      MuchStub.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