assert 2.16.4 → 2.16.5

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  data.tar.gz: 1140a1218d3b3df2195ab376b494b275155951e2
-  metadata.gz: e696cad6f5a6a309c43c72c059f7072ad7b5fa28
+  data.tar.gz: 624cea8dff7a65ada7c133ccf0ad93d8f70fb050
+  metadata.gz: f60b216b9827bab390bb1be74d2161392a087489
 SHA512: 
-  data.tar.gz: d819e6364e40bd86571d63e87b93ca4277f441914d25b862543504a58eef9ab6cc8c29a95e7db502288e526b8de62abc52c355c3f21bf372ab57d2f1a87cc00d
-  metadata.gz: 6bd08bca020ce2e980da50aec61e574270c2e77e1441d3fc84c50d91b60651713c367b00c8aa78478abdb5bb2b0a379eb120ec73cd14c27d94a049f07bb0ac25
+  data.tar.gz: 7dda4ee76847adaeb2b3044e186baa73c36c1f1f52c8575fa5afb73366636a86ef84381f9db39049e728881981add634206deb1fb9f1ba97932cecb0aa141f75
+  metadata.gz: 13e4b4811041f08d2686edad2f41654f6d711fdb9ed7f6d2863f7a090397ec8b7e9f460cfb6d1aba55f04cfe149992b5a44d57744f98fda4c001bd6223e7dea5

data/README.md

@@ -65,6 +65,16 @@ Assert is an assertion style testing framework, meaning you use assertion statem
 
 ## Stub
 
+Assert comes with a stubbing API - 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
+* stubs are auto-unstubbed on test teardown
+
+**Note**: Assert's stubbing logic has been extracted into a separate gem: [MuchStub](https://github.com/redding/much-stub/#muchstub).  However, the main `Assert.{stub|unstub|stub_send|etc}` api is still available (it just proxies MuchStub now).
+
 ```ruby
 myclass = Class.new do
   def mymeth; 'meth'; end
@@ -117,14 +127,6 @@ myobj.myval(456)
   # => 456
 ```
 
-Assert comes with a stubbing API - 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
-* stubs are auto-unstubbed on test teardown
-
 ## Factory
 
 ```ruby
@@ -173,6 +175,8 @@ module Factory
 end
 ```
 
+**Note**: Assert's factory logic has been extracted into a separate gem: [MuchFactory](https://github.com/redding/much-factory/#muchfactory).  However, the main api above is still available (it just delegates to MuchFactory now).
+
 ## CLI
 
 ```sh

data/assert.gemspec

@@ -18,4 +18,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_dependency("much-factory", ["~> 0.1.0"])
+  gem.add_dependency("much-stub",    ["~> 0.1.0"])
+
 end

data/lib/assert/factory.rb

@@ -1,162 +1,10 @@
-require 'date'
-require 'time'
+require 'much-factory'
 
 module Assert
 
   module Factory
-    extend self
-
-    def integer(max = nil)
-      self.type_cast(Random.integer(max), :integer)
-    end
-
-    def float(max = nil)
-      self.type_cast(Random.float(max), :float)
-    end
-
-    DAYS_IN_A_YEAR = 365
-    SECONDS_IN_DAY = 24 * 60 * 60
-
-    def date
-      @date ||= self.type_cast(Random.date_string, :date)
-      @date + Random.integer(DAYS_IN_A_YEAR)
-    end
-
-    def time
-      @time ||= self.type_cast(Random.time_string, :time)
-      @time + (Random.float(DAYS_IN_A_YEAR) * SECONDS_IN_DAY).to_i
-    end
-
-    def datetime
-      @datetime ||= self.type_cast(Random.datetime_string, :datetime)
-      @datetime + (Random.float(DAYS_IN_A_YEAR) * SECONDS_IN_DAY).to_i
-    end
-
-    def string(length = nil)
-      self.type_cast(Random.string(length || 10), :string)
-    end
-
-    def text(length = nil)
-      self.type_cast(Random.string(length || 20), :string)
-    end
-
-    def slug(length = nil)
-      self.type_cast(Random.string(length || 5), :string)
-    end
-
-    def hex(length = nil)
-      self.type_cast(Random.hex_string(length), :string)
-    end
-
-    def file_name(length = nil)
-      self.type_cast(Random.file_name_string(length), :string)
-    end
-
-    def dir_path(length = nil)
-      self.type_cast(Random.dir_path_string(length), :string)
-    end
-
-    def file_path
-      self.type_cast(Random.file_path_string, :string)
-    end
-
-    alias_method :path, :dir_path
-
-    def url(host = nil, length = nil)
-      self.type_cast(Random.url_string(host, length), :string)
-    end
-
-    def email(domain = nil, length = nil)
-      self.type_cast(Random.email_string(domain, length), :string)
-    end
-
-    def binary
-      self.type_cast(Random.binary, :binary)
-    end
-
-    def boolean
-      self.type_cast(Random.integer.even?, :boolean)
-    end
-
-    def type_cast(value, type)
-      self.type_converter.send(type, value)
-    end
-
-    def type_converter; TypeConverter; end
-
-    module TypeConverter
-      def self.string(input);    input.to_s;                 end
-      def self.integer(input);   input.to_i;                 end
-      def self.float(input);     input.to_f;                 end
-      def self.datetime(input);  DateTime.parse(input.to_s); end
-      def self.time(input);      Time.parse(input.to_s);     end
-      def self.date(input);      Date.parse(input.to_s);     end
-      def self.boolean(input);   !!input;                    end
-      def self.binary(input);    input;                      end
-    end
-
-    module Random
-
-      # rand given a max int value returns integers between 0 and max-1
-      def self.integer(max = nil)
-        rand(max || 32_766) + 1
-      end
-
-      # `rand` with no args gives a float between 0 and 1
-      def self.float(max = nil)
-        (max || 100).to_f * rand
-      end
-
-      def self.date_string
-        Time.now.strftime("%Y-%m-%d")
-      end
-
-      def self.datetime_string
-        Time.now.strftime("%Y-%m-%d %H:%M:%S")
-      end
-
-      def self.time_string
-        Time.now.strftime("%H:%M:%S")
-      end
-
-      DICTIONARY = [*'a'..'z'].freeze
-      def self.string(length = nil)
-        [*0..((length || 10) - 1)].map{ |n| DICTIONARY[rand(DICTIONARY.size)] }.join
-      end
-
-      def self.hex_string(length = nil)
-        length ||= 10
-        self.integer(("f" * length).hex - 1).to_s(16).rjust(length, '0')
-      end
-
-      def self.file_name_string(length = nil)
-        length ||= 6
-        "#{self.string(length)}.#{self.string(3)}"
-      end
-
-      def self.dir_path_string(length = nil)
-        length ||= 12
-        File.join(*self.string(length).scan(/.{1,4}/))
-      end
-
-      def self.file_path_string
-        File.join(self.dir_path_string, self.file_name_string)
-      end
-
-      def self.url_string(host = nil, length = nil)
-        File.join(host.to_s, self.dir_path_string(length))
-      end
-
-      def self.email_string(domain = nil, length = nil)
-        domain ||= "#{self.string(5)}.com"
-        "#{self.string(length)}@#{domain}"
-      end
-
-      def self.binary
-        [ self.integer(10000) ].pack('N*')
-      end
-
-    end
+    extend  MuchFactory
+    include MuchFactory
 
   end
 

data/lib/assert/stub.rb

@@ -1,203 +1,31 @@
+require 'much-stub'
+
 module Assert
 
   def self.stubs
-    @stubs ||= {}
+    MuchStub.stubs
   end
 
-  def self.stub(obj, meth, &block)
-    (self.stubs[Assert::Stub.key(obj, meth)] ||= begin
-      Assert::Stub.new(obj, meth, caller_locations)
-    end).tap{ |s| s.do = block }
+  def self.stub(*args, &block)
+    MuchStub.stub(*args, &block)
   end
 
-  def self.unstub(obj, meth)
-    (self.stubs.delete(Assert::Stub.key(obj, meth)) || Assert::Stub::NullStub.new).teardown
+  def self.unstub(*args)
+    MuchStub.unstub(*args)
   end
 
   def self.unstub!
-    self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
+    MuchStub.unstub!
   end
 
-  def self.stub_send(obj, meth, *args, &block)
+  def self.stub_send(*args, &block)
     orig_caller = caller_locations
-    stub = self.stubs.fetch(Assert::Stub.key(obj, meth)) do
-      raise NotStubbedError, "`#{meth}` not stubbed.", orig_caller.map(&:to_s)
-    end
-    stub.call_method(args, &block)
-  end
-
-  StubError = Class.new(ArgumentError)
-  NotStubbedError = Class.new(StubError)
-  StubArityError = Class.new(StubError)
-
-  class Stub
-
-    NullStub = Class.new do
-      def teardown; end # no-op
-    end
-
-    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 = "__assert_stub__#{object.object_id}_#{@method_name}"
-      @ivar_name = "@__assert_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)
-      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
-
-    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)
-
-      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, 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")
+    begin
+      MuchStub.stub_send(*args, &block)
+    rescue MuchStub::NotStubbedError => err
+      err.set_backtrace(orig_caller.map(&:to_s))
+      raise err
     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
-
-    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.16.4"
+  VERSION = "2.16.5"
 end

data/test/unit/assert_tests.rb

@@ -2,6 +2,7 @@ require 'assert'
 
 require 'assert/config'
 require 'assert/stub'
+require 'much-stub'
 
 module Assert
 
@@ -41,7 +42,7 @@ module Assert
 
     should "build a stub" do
       stub1 = Assert.stub(@myobj, :mymeth)
-      assert_kind_of Assert::Stub, stub1
+      assert_kind_of MuchStub::Stub, stub1
     end
 
     should "lookup stubs that have been called before" do
@@ -52,7 +53,7 @@ module Assert
 
     should "set the stub's do block if given a block" do
       Assert.stub(@myobj, :mymeth)
-      assert_raises(NotStubbedError){ @myobj.mymeth }
+      assert_raises(MuchStub::NotStubbedError){ @myobj.mymeth }
       Assert.stub(@myobj, :mymeth){ @stub_value }
       assert_equal @stub_value, @myobj.mymeth
     end
@@ -96,7 +97,7 @@ module Assert
     end
 
     should "be able to call a stub's original method" do
-      err = assert_raises(NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
+      err = assert_raises(MuchStub::NotStubbedError){ Assert.stub_send(@myobj, :mymeth) }
       assert_includes 'not stubbed.',              err.message
       assert_includes 'test/unit/assert_tests.rb', err.backtrace.first
 

data/test/unit/factory_tests.rb

@@ -1,166 +1,27 @@
 require 'assert'
 require 'assert/factory'
 
+require 'much-factory'
+
 module Assert::Factory
 
   class UnitTests < Assert::Context
     desc "Assert::Factory"
     subject{ Assert::Factory }
 
-    should have_imeths :integer, :float
-    should have_imeths :date, :time, :datetime
-    should have_imeths :string, :text, :slug, :hex
-    should have_imeths :file_name, :dir_path, :file_path
-    should have_imeths :path, :url, :email
-    should have_imeths :binary, :boolean
-    should have_imeths :type_cast, :type_converter
-
-    should "return a random integer using `integer`" do
-      assert_kind_of Integer, subject.integer
-    end
-
-    should "allow passing a maximum value using `integer`" do
-      assert_includes subject.integer(2), [1, 2]
-    end
-
-    should "return a random float using `float`" do
-      assert_kind_of Float, subject.float
-    end
-
-    should "allow passing a maximum value using `float`" do
-      float = subject.float(2)
-      assert float <= 2
-      assert float >= 0
-
-      float = subject.float(0)
-      assert_equal 0.0, float
-    end
-
-    should "return a random date using `date`" do
-      assert_kind_of Date, subject.date
-    end
-
-    should "return a random time object using `time`" do
-      assert_kind_of Time, subject.time
-    end
-
-    should "return a random time object using `datetime`" do
-      assert_kind_of DateTime, subject.datetime
-    end
-
-    should "return a random string using `string`" do
-      assert_kind_of String, subject.string
-      assert_equal 10, subject.string.length
-    end
-
-    should "allow passing a maximum length using `string`" do
-      assert_equal 1, subject.string(1).length
-    end
-
-    should "return a random string using `text`" do
-      assert_kind_of String, subject.text
-      assert_equal 20, subject.text.length
-    end
-
-    should "allow passing a maximum length using `text`" do
-      assert_equal 1, subject.text(1).length
-    end
-
-    should "return a random string using `slug`" do
-      assert_kind_of String, subject.slug
-      assert_equal 5, subject.slug.length
-    end
-
-    should "allow passing a maximum length using `slug`" do
-      assert_equal 1, subject.slug(1).length
-    end
-
-    should "return a random hex string using `hex`" do
-      assert_kind_of String, subject.hex
-      assert_match /\A[0-9a-f]{10}\Z/, subject.hex
-    end
-
-    should "allow passing a maximum length using `hex`" do
-      assert_equal 1, subject.hex(1).length
-    end
-
-    should "return a random file name string using `file_name`" do
-      assert_kind_of String, subject.file_name
-      assert_match /\A[a-z]{6}\.[a-z]{3}\Z/, subject.file_name
-    end
-
-    should "allow passing a name length using `file_name`" do
-      assert_match /\A[a-z]{1}.[a-z]{3}\Z/, subject.file_name(1)
-    end
+    should "include and extend MuchFactory" do
+      assert_includes MuchFactory, subject
 
-    should "return a random folder path string using `dir_path`" do
-      assert_kind_of String, subject.dir_path
-      path_segments = subject.dir_path.split('/')
-      assert_equal 3, path_segments.size
-      path_segments.each{ |s| assert_match /\A[a-z]{4}\Z/, s }
+      # https://stackoverflow.com/questions/5197166/ruby-get-a-list-of-extended-modules
+      assert_includes MuchFactory, subject_metaclass.included_modules
     end
 
-    should "allow passing a maximum length using `dir_path`" do
-      assert_equal 1, subject.dir_path(1).length
-    end
-
-    should "return a random folder path and file name using `file_path`" do
-      assert_kind_of String, subject.file_path
-      segments = subject.file_path.split('/')
-      assert_equal 4, segments.size
-      segments[0..-2].each{ |s| assert_match /\A[a-z]{4}\Z/, s }
-      assert_match /\A[a-z]{6}\.[a-z]{3}\Z/, segments.last
-    end
-
-    should "return a random url string using `url`" do
-      u = subject.url
-      segments = u.split('/')
-
-      assert_kind_of String, u
-      assert_match /\A\//, u
-      assert_equal 4, segments.size
-      segments[1..-1].each{ |s| assert_match /\A[a-z]{4}\Z/, s }
-    end
-
-    should "allow passing a host string using `url`" do
-      host = "example.com"
-      assert_match /\A#{host}\//, subject.url(host)
-    end
-
-    should "allow passing a maximum length using `url`" do
-      assert_equal 2, subject.url('', 1).length # plus leading '/'
-    end
-
-    should "return a random email string using `email`" do
-      e = subject.email
-      assert_kind_of String, e
-      assert_match /\A\w+@\w+\.com\Z/, e
-    end
-
-    should "allow passing a custom domain to `email`" do
-      e = subject.email('example.org')
-      assert_match /@example\.org\Z/, e
-    end
-
-    should "allow passing a mailbox length using `email`" do
-      assert_equal 2, subject.email(nil, 2).split('@').first.size
-    end
-
-    should "return a random binary string using `binary`" do
-      assert_kind_of String, subject.binary
-    end
-
-    should "return a random boolean using `boolean`" do
-      assert_includes subject.boolean.class, [ TrueClass, FalseClass ]
-    end
-
-    should "type cast values to a specified type using `type_cast`" do
-      expected = Date.parse('2013-01-01')
-      assert_equal expected, subject.type_cast('2013-01-01', :date)
-    end
+    private
 
-    should "use `TypedConverter` for the default type converter" do
-      assert_equal TypeConverter, subject.type_converter
+    def subject_metaclass
+      class << subject
+        self
+      end
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  version: 2.16.4
+  version: 2.16.5
 platform: ruby
 authors: 
 - Kelly Redding
@@ -10,9 +10,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2018-05-13 00:00:00 Z
-dependencies: []
-
+date: 2018-06-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: much-factory
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - &id002 !ruby/object:Gem::Version 
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: much-stub
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - *id002
+  type: :runtime
+  version_requirements: *id003
 description: Assertion style testing framework.
 email: 
 - kelly@kellyredding.com
@@ -97,7 +115,6 @@ files:
 - test/unit/macro_tests.rb
 - test/unit/result_tests.rb
 - test/unit/runner_tests.rb
-- test/unit/stub_tests.rb
 - test/unit/suite_tests.rb
 - test/unit/test_tests.rb
 - test/unit/utils_tests.rb
@@ -116,13 +133,13 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - &id001 
+  - &id004 
     - ">="
     - !ruby/object:Gem::Version 
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - *id001
+  - *id004
 requirements: []
 
 rubyforge_project: 
@@ -168,7 +185,6 @@ test_files:
 - test/unit/macro_tests.rb
 - test/unit/result_tests.rb
 - test/unit/runner_tests.rb
-- test/unit/stub_tests.rb
 - test/unit/suite_tests.rb
 - test/unit/test_tests.rb
 - test/unit/utils_tests.rb

data/test/unit/stub_tests.rb

@@ -1,375 +0,0 @@
-require 'assert'
-require 'assert/stub'
-
-require 'assert/factory'
-
-class Assert::Stub
-
-  class UnitTests < Assert::Context
-    desc "Assert::Stub"
-    setup do
-      @myclass = Class.new do
-        def mymeth; 'meth'; end
-        def myval(val); val; end
-        def myargs(*args); args; end
-        def myvalargs(val1, val2, *args); [val1, val2, args]; end
-        def myblk(&block); block.call; end
-      end
-      @myobj = @myclass.new
-
-      @stub = Assert::Stub.new(@myobj, :mymeth)
-    end
-    subject{ @stub }
-
-    should have_readers :method_name, :name, :ivar_name, :do
-    should have_writers :do
-    should have_cmeths :key
-    should have_imeths :call_method, :call, :with, :teardown
-
-    should "generate a key given an object and method name" do
-      obj = @myobj
-      meth = :mymeth
-      assert_equal "--#{obj.object_id}--#{meth}--", Assert::Stub.key(obj, meth)
-    end
-
-    should "know its names" do
-      assert_equal 'mymeth', subject.method_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
-      err = assert_raises(Assert::NotStubbedError){ @myobj.mymeth }
-      assert_includes 'not stubbed.',            err.message
-      assert_includes 'test/unit/stub_tests.rb', err.backtrace.first
-
-      subject.do = proc{ 'mymeth' }
-      assert_nothing_raised do
-        @myobj.mymeth
-      end
-
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :mymeth){ 'mymeth' }
-      end
-    end
-
-    should "complain if stubbing a method that the object doesn't respond to" do
-      err = assert_raises(Assert::StubError){ Assert::Stub.new(@myobj, :some_other_meth) }
-      assert_includes 'does not respond to',     err.message
-      assert_includes 'test/unit/stub_tests.rb', err.backtrace.first
-    end
-
-    should "complain if stubbed and called with no `do` proc given" do
-      assert_raises(Assert::NotStubbedError){ @myobj.mymeth }
-    end
-
-    should "complain if stubbed and called with mismatched arity" do
-      Assert::Stub.new(@myobj, :myval){ 'myval' }
-      err = assert_raises(Assert::StubArityError){ @myobj.myval }
-      assert_includes 'arity mismatch on',       err.message
-      assert_includes 'test/unit/stub_tests.rb', err.backtrace.first
-
-      assert_nothing_raised { @myobj.myval(1) }
-      assert_raises(Assert::StubArityError){ @myobj.myval(1,2) }
-
-      Assert::Stub.new(@myobj, :myargs){ 'myargs' }
-      assert_nothing_raised { @myobj.myargs }
-      assert_nothing_raised { @myobj.myargs(1) }
-      assert_nothing_raised { @myobj.myargs(1,2) }
-
-      Assert::Stub.new(@myobj, :myvalargs){ 'myvalargs' }
-      assert_raises(Assert::StubArityError){ @myobj.myvalargs }
-      assert_raises(Assert::StubArityError){ @myobj.myvalargs(1) }
-      assert_nothing_raised { @myobj.myvalargs(1,2) }
-      assert_nothing_raised { @myobj.myvalargs(1,2,3) }
-    end
-
-    should "complain if stubbed with mismatched arity" do
-      err = assert_raises(Assert::StubArityError) do
-        Assert::Stub.new(@myobj, :myval).with(){ 'myval' }
-      end
-      assert_includes 'arity mismatch on',       err.message
-      assert_includes 'test/unit/stub_tests.rb', err.backtrace.first
-
-      assert_raises(Assert::StubArityError) do
-        Assert::Stub.new(@myobj, :myval).with(1,2){ 'myval' }
-      end
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :myval).with(1){ 'myval' }
-      end
-
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :myargs).with(){ 'myargs' }
-      end
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :myargs).with(1,2){ 'myargs' }
-      end
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :myargs).with(1){ 'myargs' }
-      end
-
-      assert_raises(Assert::StubArityError) do
-        Assert::Stub.new(@myobj, :myvalargs).with(){ 'myvalargs' }
-      end
-      assert_raises(Assert::StubArityError) do
-        Assert::Stub.new(@myobj, :myvalargs).with(1){ 'myvalargs' }
-      end
-      assert_nothing_raised do
-        Assert::Stub.new(@myobj, :myvalargs).with(1,2){ 'myvalargs' }
-      end
-      assert_nothing_raised do
-        Assert::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
-      Assert::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 = Assert::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)
-    end
-
-    should "stub methods with variable args" do
-      assert_equal [1,2], @myobj.myargs(1,2)
-      stub = Assert::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)
-    end
-
-    should "stub methods with required args and variable args" do
-      assert_equal [1,2, [3]], @myobj.myvalargs(1,2,3)
-      stub = Assert::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)
-    end
-
-    should "stub methods that yield blocks" do
-      blkcalled = false
-      blk = proc{ blkcalled = true }
-      @myobj.myblk(&blk)
-      assert_equal true, blkcalled
-
-      blkcalled = false
-      Assert::Stub.new(@myobj, :myblk){ blkcalled = 'true' }
-      @myobj.myblk(&blk)
-      assert_equal 'true', blkcalled
-    end
-
-    should "stub methods even if they are not local to the object" do
-      mydelegatorclass = Class.new do
-        def initialize(delegateclass)
-          @delegate = delegateclass.new
-        end
-        def respond_to?(meth)
-          @delegate.respond_to?(meth) || super
-        end
-        def method_missing(meth, *args, &block)
-          respond_to?(meth) ? @delegate.send(meth, *args, &block) : super
-        end
-      end
-      mydelegator = mydelegatorclass.new(@myclass)
-
-      assert_equal [1,2,[3]], mydelegator.myvalargs(1,2,3)
-      stub = Assert::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)
-    end
-
-    should "call to the original method" do
-      subject.teardown
-
-      # no args
-      stub = Assert::Stub.new(@myobj, :mymeth){ 'mymeth' }
-      assert_equal 'mymeth', stub.call([])
-      assert_equal 'meth',   stub.call_method([])
-
-      # static args
-      stub = Assert::Stub.new(@myobj, :myval){ |val| val.to_s }
-      assert_equal '1', stub.call([1])
-      assert_equal 1,   stub.call_method([1])
-      assert_equal '2', stub.call([2])
-      assert_equal 2,   stub.call_method([2])
-      stub.with(2){ 'two' }
-      assert_equal 'two', stub.call([2])
-      assert_equal 2,     stub.call_method([2])
-
-      # dynamic args
-      stub = Assert::Stub.new(@myobj, :myargs){ |*args| args.join(',') }
-      assert_equal '1,2',   stub.call([1,2])
-      assert_equal [1,2],   stub.call_method([1,2])
-      assert_equal '3,4,5', stub.call([3,4,5])
-      assert_equal [3,4,5], stub.call_method([3,4,5])
-      stub.with(3,4,5){ 'three-four-five' }
-      assert_equal 'three-four-five', stub.call([3,4,5])
-      assert_equal [3,4,5],           stub.call_method([3,4,5])
-
-      # mixed static/dynamic args
-      stub = Assert::Stub.new(@myobj, :myvalargs){ |*args| args.join(',') }
-      assert_equal '1,2,3',    stub.call([1,2,3])
-      assert_equal [1,2, [3]], stub.call_method([1,2,3])
-      assert_equal '3,4,5',    stub.call([3,4,5])
-      assert_equal [3,4,[5]],  stub.call_method([3,4,5])
-      stub.with(3,4,5){ 'three-four-five' }
-      assert_equal 'three-four-five', stub.call([3,4,5])
-      assert_equal [3,4,[5]],         stub.call_method([3,4,5])
-
-      # blocks
-      blkcalled = false
-      blk = proc{ blkcalled = true }
-      stub = Assert::Stub.new(@myobj, :myblk){ blkcalled = 'true' }
-      stub.call([], &blk)
-      assert_equal 'true', blkcalled
-      stub.call_method([], &blk)
-      assert_equal true, blkcalled
-    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 }
-      assert_equal '1', @myobj.myval(1)
-      stub.teardown
-      assert_equal 1, @myobj.myval(1)
-    end
-
-    should "have a readable inspect" do
-      expected = "#<#{subject.class}:#{'0x0%x' % (subject.object_id << 1)}" \
-                 " @method_name=#{subject.method_name.inspect}>"
-      assert_equal expected, subject.inspect
-    end
-
-  end
-
-  class MutatingArgsStubTests < UnitTests
-    desc "with args that are mutated after they've been used to stub"
-    setup do
-      @arg = ChangeHashObject.new
-
-      @stub = Assert::Stub.new(@myobj, :myval)
-      @stub.with(@arg){ true }
-
-      @arg.change!
-    end
-    subject{ @stub }
-
-    should "not raise a stub error when called" do
-      assert_nothing_raised{ @stub.call([@arg]) }
-    end
-
-  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
-      @ns = NullStub.new
-    end
-    subject{ @ns }
-
-    should have_imeths :teardown
-
-  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
-    end
-
-    def hash
-      @value.hash
-    end
-
-    def change!
-      @value = 1
-    end
-  end
-
-end