assert 2.10.1 → 2.11.0

data/Gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'pry'
+gem 'pry', "~> 0.9.0"
 
 platform :rbx do
   gem 'rubysl'

data/README.md

@@ -40,7 +40,7 @@ Running tests in random order, seeded with "56382"
 
 * **Rspec**
 * **Unit/Functional/Integration/etc**: Assert is agnostic - you define whatever kinds of tests you like (one or more of the above) and assert runs them in context.
-* **Mock/Spec/BDD/Factories/etc**: Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like.
+* **Mock/Spec/BDD/etc**: Assert is the framework and there are a variety of 3rd party tools to do such things - feel free to use whatever you like.
 
 ## Description
 
@@ -50,6 +50,70 @@ In addition, Assert adds some helpers and syntax sugar to enhance the way tests
 
 **Note**: Assert is tested using itself.  The tests are a pretty good place to look for examples and usage patterns.
 
+## Defining tests
+
+TODO
+
+## Factory
+
+TODO
+
+## Stub
+
+```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
+
+Assert.stub(myobj, :mymeth)
+myobj.mymeth
+  # => StubError: `mymeth` not stubbed.
+Assert.stub(myobj, :mymeth){ 'stub-meth' }
+myobj.mymeth
+  # => 'stub-meth'
+myobj.mymeth(123)
+  # => StubError: arity mismatch
+Assert.stub(myobj, :mymeth).with(123){ 'stub-meth' }
+  # => StubError: arity mismatch
+
+Assert.stub(myobj, :myval){ 'stub-meth' }
+  # => StubError: arity mismatch
+Assert.stub(myobj, :myval).with(123){ |val| val.to_s }
+myobj.myval
+  # => StubError: arity mismatch
+myobj.mymeth(123)
+  # => '123'
+myobj.mymeth(456)
+  # => StubError: `mymeth(456)` not stubbed.
+
+Assert.unstub(myobj, :mymeth)
+
+myobj.mymeth
+  # => 'meth'
+myobj.myval(123)
+  # => 123
+myobj.myval(456)
+  # => 456
+```
+
+Assert comes with a simple 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 added to `Object`
+* stubs are auto-unstubbed on test teardown
+
 ## CLI
 
 ```sh

data/lib/assert.rb

@@ -3,6 +3,7 @@ require 'assert/version'
 require 'assert/config'
 require 'assert/context'
 require 'assert/runner'
+require 'assert/stub'
 require 'assert/suite'
 require 'assert/utils'
 require 'assert/view'
@@ -16,4 +17,28 @@ module Assert
   def self.suite;  self.config.suite;  end
   def self.runner; self.config.runner; end
 
+  def self.stubs
+    @stubs ||= {}
+  end
+
+  def self.stub(*args, &block)
+    (self.stubs[Assert::Stub.key(*args)] ||= Assert::Stub.new(*args)).tap do |s|
+      s.do = block
+    end
+  end
+
+  def self.unstub(*args)
+    (self.stubs.delete(Assert::Stub.key(*args)) || Assert::Stub::NullStub.new).teardown
+  end
+
+  def self.unstub!
+    self.stubs.keys.each{ |key| self.stubs.delete(key).teardown }
+  end
+
+  class Context
+
+    teardown{ Assert.unstub! } # unstub all stubs automatically
+
+  end
+
 end

data/lib/assert/stub.rb

@@ -0,0 +1,95 @@
+module Assert
+
+  StubError = Class.new(ArgumentError)
+
+  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, :do
+
+    def initialize(object, method_name, &block)
+      @metaclass = class << object; self; end
+      @method_name = method_name.to_s
+      @name = "__assert_stub__#{@method_name}"
+
+      setup(object)
+
+      @do = block || Proc.new do |*args, &block|
+        err_msg = "#{inspect_call(args)} not stubbed."
+        inspect_lookup_stubs.tap do |stubs|
+          err_msg += "\nStubs:\n#{stubs}" if !stubs.empty?
+        end
+        raise StubError, err_msg
+      end
+      @lookup = Hash.new{ |hash, key| self.do }
+    end
+
+    def call(*args, &block)
+      raise StubError, "artiy mismatch" unless arity_matches?(args)
+      @lookup[args].call(*args, &block)
+    end
+
+    def with(*args, &block)
+      raise StubError, "artiy mismatch" unless arity_matches?(args)
+      @lookup[args] = block
+    end
+
+    def do=(block)
+      @do = block || @do
+    end
+
+    def teardown
+      @metaclass.send(:undef_method, @method_name)
+      @metaclass.send(:alias_method, @method_name, @name)
+      @metaclass.send(:undef_method, @name)
+    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)
+        @metaclass.send(:define_method, @method_name) do |*args, &block|
+          super(*args, &block)
+        end
+      end
+
+      if !object.respond_to?(@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
+    end
+
+    private
+
+    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
+
+  end
+
+end

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.10.1"
+  VERSION = "2.11.0"
 end

data/test/unit/assert_tests.rb

@@ -1,14 +1,16 @@
 require 'assert'
 
 require 'assert/config'
+require 'assert/stub'
 
 module Assert
 
   class UnitTests < Assert::Context
-    desc "the Assert module"
+    desc "Assert"
     subject { Assert }
 
     should have_imeths :config, :configure, :view, :suite, :runner
+    should have_imeths :stubs, :stub, :unstub, :unstub!
 
     should "know its config instance" do
       assert_kind_of Assert::Config, subject.config
@@ -25,4 +27,70 @@ module Assert
 
   end
 
+  class StubTests < UnitTests
+    setup do
+      @myclass = Class.new do
+        def mymeth; 'meth'; end
+      end
+      @myobj = @myclass.new
+    end
+
+    should "build a stub" do
+      stub1 = Assert.stub(@myobj, :mymeth)
+      assert_kind_of Assert::Stub, stub1
+    end
+
+    should "lookup stubs that have been called before" do
+      stub1 = Assert.stub(@myobj, :mymeth)
+      stub2 = Assert.stub(@myobj, :mymeth)
+      assert_same stub1, stub2
+    end
+
+    should "set the stub's do block if given a block" do
+      Assert.stub(@myobj, :mymeth)
+      assert_raises(StubError){ @myobj.mymeth }
+      Assert.stub(@myobj, :mymeth){ 'mymeth' }
+      assert_equal 'mymeth', @myobj.mymeth
+    end
+
+    should "teardown stubs" do
+      assert_equal 'meth', @myobj.mymeth
+      Assert.unstub(@myobj, :mymeth)
+      assert_equal 'meth', @myobj.mymeth
+
+      assert_equal 'meth', @myobj.mymeth
+      Assert.stub(@myobj, :mymeth){ 'mymeth' }
+      assert_equal 'mymeth', @myobj.mymeth
+      Assert.unstub(@myobj, :mymeth)
+      assert_equal 'meth', @myobj.mymeth
+    end
+
+    should "know and teardown all stubs" do
+      assert_equal 'meth', @myobj.mymeth
+
+      Assert.stub(@myobj, :mymeth){ 'mymeth' }
+      assert_equal 'mymeth', @myobj.mymeth
+      assert_equal 1, Assert.stubs.size
+
+      Assert.unstub!
+      assert_equal 'meth', @myobj.mymeth
+      assert_empty Assert.stubs
+    end
+
+    should "auto-unstub any stubs on teardown" do
+      context_class = ::Factory.modes_off_context_class do
+        setup do
+          Assert.stub('1', :to_s){ 'one' }
+        end
+      end
+
+      context_class.run_setups('scope')
+      assert_equal 1, Assert.stubs.size
+
+      context_class.run_teardowns('scope')
+      assert_empty Assert.stubs
+    end
+
+  end
+
 end

data/test/unit/assertions/assert_includes_tests.rb

@@ -34,7 +34,7 @@ module Assert::Assertions
 
   end
 
-  class AssertNotIncluded < Assert::Context
+  class AssertNotIncludedTests < Assert::Context
     desc "`assert_not_included`"
     setup do
       desc = @desc = "assert not included fail desc"

data/test/unit/assertions/assert_respond_to_tests.rb

@@ -5,7 +5,7 @@ require 'assert/utils'
 
 module Assert::Assertions
 
-  class AssertRespondToTest < Assert::Context
+  class AssertRespondToTests < Assert::Context
     desc "`assert_respond_to`"
     setup do
       desc = @desc = "assert respond to fail desc"

data/test/unit/assertions/assert_same_tests.rb

@@ -5,7 +5,7 @@ require 'assert/utils'
 
 module Assert::Assertions
 
-  class AssertSameTest < Assert::Context
+  class AssertSameTests < Assert::Context
     desc "`assert_same`"
     setup do
       klass = Class.new; object = klass.new

data/test/unit/assertions_tests.rb

@@ -4,7 +4,7 @@ require 'assert/assertions'
 module Assert::Assertions
 
   class UnitTests < Assert::Context
-    desc "An assert context"
+    desc "Assert::Context"
     setup do
       @context_class = Factory.modes_off_context_class
       @test = Factory.test

data/test/unit/context_tests.rb

@@ -7,7 +7,7 @@ require 'assert/utils'
 class Assert::Context
 
   class UnitTests < Assert::Context
-    desc "Assert context"
+    desc "Assert::Context"
     setup do
       @test = Factory.test
       @context_class = @test.context_class

data/test/unit/macro_tests.rb

@@ -4,7 +4,7 @@ require 'assert/macro'
 class Assert::Macro
 
   class UnitTests < Assert::Context
-    desc "a macro"
+    desc "Assert::Macro"
     setup do
       @macro = Assert::Macro.new {}
     end
@@ -34,7 +34,7 @@ class Assert::Macro
   end
 
   class InstanceMethodsTests < Assert::Context
-    desc "a class with instance methods"
+    desc "have_instance_methods macro: this class"
     subject do
       class ::InstExample
         (1..6).each {|i| define_method("method_#{i}") {}}
@@ -55,7 +55,7 @@ class Assert::Macro
   end
 
   class ClassMethodsTests < Assert::Context
-    desc "a class with class methods"
+    desc "have_class_methods macro: this class"
     subject do
       class ::ClassExample
         class << self
@@ -78,7 +78,7 @@ class Assert::Macro
   end
 
   class ReadersTests < Assert::Context
-    desc "a class with readers"
+    desc "have_readers macro: this class"
     subject do
       class ::ReaderExample
         (1..6).each {|i| attr_reader "method_#{i}"}
@@ -99,7 +99,7 @@ class Assert::Macro
   end
 
   class WritersTests < Assert::Context
-    desc "a class with writers"
+    desc "have_writers macro: this class"
     subject do
       class ::WriterExample
         (1..6).each {|i| attr_writer "method_#{i}"}
@@ -120,7 +120,7 @@ class Assert::Macro
   end
 
   class AccessorsTests < Assert::Context
-    desc "a class with accessors"
+    desc "have_accessors macro: this class"
     subject do
       class ::AccessorExample
         (1..6).each {|i| attr_accessor "method_#{i}"}

data/test/unit/result_tests.rb

@@ -4,7 +4,7 @@ require 'assert/result'
 module Assert::Result
 
   class BacktraceTests < Assert::Context
-    desc "a result backtrace"
+    desc "Assert::Result::Backtrace"
     setup do
       @backtrace = Backtrace.new(caller)
     end
@@ -30,8 +30,8 @@ module Assert::Result
 
   end
 
-  class UnitTests < Assert::Context
-    desc "a base result"
+  class BaseTests < Assert::Context
+    desc "Assert::Result::Base"
     setup do
       @test = Factory.test("a test name")
       @result = Assert::Result::Base.new(@test, "a message", ["line 1", "line2"])
@@ -73,10 +73,6 @@ module Assert::Result
       assert_equal ['bt'], subject.backtrace
     end
 
-  end
-
-  class ToStringTests < UnitTests
-
     should "include its test context name in the to_s" do
       assert subject.to_s.include?(subject.test_name)
     end
@@ -99,14 +95,14 @@ module Assert::Result
   end
 
   class PassTests < Assert::Context
-    desc "a pass result"
+    desc "Assert::Result::Pass"
     setup do
       @test = Factory.test("a test name")
       @result = Assert::Result::Pass.new(@test, "passed", [])
     end
     subject { @result }
 
-    should "be pass?" do
+    should "pass?" do
       assert_equal true, subject.pass?
     end
 
@@ -131,14 +127,14 @@ module Assert::Result
   end
 
   class IgnoreTests < Assert::Context
-    desc "an ignore result"
+    desc "Assert::Result::Ignore"
     setup do
       @test = Factory.test("a test name")
       @result = Assert::Result::Ignore.new(@test, "ignored", [])
     end
     subject { @result }
 
-    should "be ignore?" do
+    should "ignore?" do
       assert_equal true, subject.ignore?
     end
 
@@ -163,7 +159,7 @@ module Assert::Result
   end
 
   class FailTests < Assert::Context
-    desc "a fail result"
+    desc "Assert::Result::Fail"
     setup do
       @test = Factory.test("a test name")
       @result = Assert::Result::Fail.new(@test, "failed", [])
@@ -174,7 +170,7 @@ module Assert::Result
       assert_kind_of RuntimeError, Assert::Result::TestFailure.new
     end
 
-    should "be fail?" do
+    should "fail?" do
       assert_equal true, subject.fail?
     end
 
@@ -199,7 +195,7 @@ module Assert::Result
   end
 
   class SkipTests < Assert::Context
-    desc "a skip result"
+    desc "Assert::Result::Skip"
     setup do
       @test = Factory.test("a test name")
       @exception = nil
@@ -216,7 +212,7 @@ module Assert::Result
       assert_kind_of RuntimeError, Assert::Result::TestSkipped.new
     end
 
-    should "be skip?" do
+    should "skip?" do
       assert_equal true, subject.skip?
     end
 
@@ -241,7 +237,7 @@ module Assert::Result
   end
 
   class ErrorTests < Assert::Context
-    desc "an error result"
+    desc "Assert::Result::Error"
     setup do
       @test = Factory.test("a test name")
       @exception = nil
@@ -254,7 +250,7 @@ module Assert::Result
     end
     subject { @result }
 
-    should "be error?" do
+    should "error?" do
       assert_equal true, subject.error?
     end
 

data/test/unit/runner_tests.rb

@@ -5,8 +5,8 @@ require 'assert/runner'
 
 class Assert::Runner
 
-  class BasicTests < Assert::Context
-    desc "a basic runner"
+  class UnitTests < Assert::Context
+    desc "Assert::Runner"
     setup do
       @config = Factory.modes_off_config
       @suite  = Assert::Suite.new(@config)

data/test/unit/stub_tests.rb

@@ -0,0 +1,195 @@
+require 'assert'
+require 'assert/stub'
+
+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, :do
+    should have_writers :do
+    should have_cmeths :key
+
+    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
+      assert_equal "__assert_stub__#{subject.method_name}", subject.name
+    end
+
+    should "complain when called if no do block was given" do
+      assert_raises Assert::StubError do
+        @myobj.mymeth
+      end
+
+      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
+      assert_raises Assert::StubError do
+        Assert::Stub.new(@myobj, :some_other_meth)
+      end
+    end
+
+    should "complain if stubbed and called with no `do` proc given" do
+      assert_raises(Assert::StubError){ @myobj.mymeth }
+    end
+
+    should "complain if stubbed and called with mismatched arity" do
+      Assert::Stub.new(@myobj, :myval){ 'myval' }
+      assert_raises(Assert::StubError){ @myobj.myval }
+      assert_nothing_raised { @myobj.myval(1) }
+      assert_raises(Assert::StubError){ @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::StubError){ @myobj.myvalargs }
+      assert_raises(Assert::StubError){ @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
+      assert_raises(Assert::StubError) do
+        Assert::Stub.new(@myobj, :myval).with(){ 'myval' }
+      end
+      assert_raises(Assert::StubError) 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::StubError) do
+        Assert::Stub.new(@myobj, :myvalargs).with(){ 'myvalargs' }
+      end
+      assert_raises(Assert::StubError) 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 from a super class" do
+      mysubclass = Class.new(@myclass)
+      mysubobj = mysubclass.new
+
+      assert_equal 1, mysubobj.myval(1)
+      stub = Assert::Stub.new(mysubobj, :myval){ |val| val.to_s }
+      assert_equal '1', mysubobj.myval(1)
+      assert_equal '2', mysubobj.myval(2)
+      stub.with(2){ 'two' }
+      assert_equal 'two', mysubobj.myval(2)
+    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
+
+  end
+
+  class NullStubTests < UnitTests
+    desc "NullStub"
+    setup do
+      @ns = NullStub.new
+    end
+    subject{ @ns }
+
+    should have_imeths :teardown
+
+  end
+
+end

data/test/unit/test_tests.rb

@@ -5,8 +5,8 @@ require 'assert/config'
 
 class Assert::Test
 
-  class BasicTests < Assert::Context
-    desc "a test obj"
+  class UnitTests < Assert::Context
+    desc "Assert::Test"
     setup do
       @test_code = lambda{ assert(true) }
       @context_class = Factory.modes_off_context_class{ desc "context class" }
@@ -68,7 +68,7 @@ class Assert::Test
 
   end
 
-  class PassFailIgnoreTotalTests < BasicTests
+  class PassFailIgnoreTotalTests < UnitTests
     setup do
       @test = Factory.test("pass fail ignore test", @context_info) do
         ignore("something")
@@ -122,7 +122,7 @@ class Assert::Test
 
   end
 
-  class SkipHandlingTests < BasicTests
+  class SkipHandlingTests < UnitTests
     setup do
       @test = Factory.test("skip test", @context_info){ skip }
       @test.run
@@ -163,7 +163,7 @@ class Assert::Test
 
   end
 
-  class ErrorHandlingTests < BasicTests
+  class ErrorHandlingTests < UnitTests
     setup do
       @test = Factory.test("error test", @context_info) do
         raise StandardError, "WHAT"
@@ -206,7 +206,7 @@ class Assert::Test
 
   end
 
-  class SignalExceptionHandlingTests < BasicTests
+  class SignalExceptionHandlingTests < UnitTests
     setup do
       @test = Factory.test("signal test", @context_info) do
         raise SignalException, "USR1"
@@ -234,7 +234,7 @@ class Assert::Test
 
   end
 
-  class ComparingTests < BasicTests
+  class ComparingTests < UnitTests
     desc "<=> another test"
     setup do
       @test = Factory.test("mmm")
@@ -258,7 +258,7 @@ class Assert::Test
 
   end
 
-  class CaptureOutTests < BasicTests
+  class CaptureOutTests < UnitTests
     desc "when capturing std out"
     setup do
       @capture_config = Assert::Config.new(:capture_output => true)

data/test/unit/view_tests.rb

@@ -47,10 +47,11 @@ class Assert::View::Base
   end
 
   class HandlerTests < Assert::Context
-    desc 'the assert view handler'
+    desc "Assert::View"
     subject { Assert::View }
 
     should have_instance_method :require_user_view
+
   end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert
 version: !ruby/object:Gem::Version 
-  hash: 37
+  hash: 35
   prerelease: 
   segments: 
   - 2
-  - 10
-  - 1
-  version: 2.10.1
+  - 11
+  - 0
+  version: 2.11.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,12 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-04-24 00:00:00 Z
+date: 2014-06-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  type: :runtime
-  name: ansi
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -31,8 +29,10 @@ dependencies:
         - 1
         - 3
         version: "1.3"
+  type: :runtime
+  name: ansi
+  version_requirements: *id001
   prerelease: false
-  requirement: *id001
 description: Test::Unit style testing framework, just better than Test::Unit.
 email: 
 - kelly@kellyredding.com
@@ -67,6 +67,7 @@ files:
 - lib/assert/macros/methods.rb
 - lib/assert/result.rb
 - lib/assert/runner.rb
+- lib/assert/stub.rb
 - lib/assert/suite.rb
 - lib/assert/test.rb
 - lib/assert/utils.rb
@@ -108,6 +109,7 @@ 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
@@ -142,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Test::Unit style testing framework, just better than Test::Unit.
@@ -178,6 +180,7 @@ 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