assert 2.18.0 → 2.19.0

data/lib/assert/context.rb

@@ -1,4 +1,7 @@
+require "assert/actual_value"
 require "assert/assertions"
+require "assert/context/let_dsl"
+require "assert/context/method_missing"
 require "assert/context/setup_dsl"
 require "assert/context/subject_dsl"
 require "assert/context/suite_dsl"
@@ -10,42 +13,22 @@ require "assert/suite"
 require "assert/utils"
 
 module Assert
+  # A Context is a scope for tests to run in. Contexts have setup and teardown
+  # blocks, subjects, and descriptions. Tests are run in the scope of a Context
+  # instance. Therefore, a Context should have minimal base
+  # logic/methods/instance_vars. The instance should remain pure to not pollute
+  # test scopes.
   class Context
-    # put all logic in DSL methods to keep context instances pure for running tests
+    # Put all logic in DSL methods to keep context instances pure.
     extend SetupDSL
     extend SubjectDSL
     extend SuiteDSL
     extend TestDSL
+    extend LetDSL
+    include MethodMissing
     include Assert::Assertions
     include Assert::Macros::Methods
 
-    # a Context is a scope for tests to run in.  Contexts have setup and
-    # teardown blocks, subjects, and descriptions.  Tests are run in the
-    # scope of a Context instance.  Therefore, a Context should have
-    # minimal base logic/methods/instance_vars.  The instance should remain
-    # pure to not pollute test scopes.
-
-    # if a test method is added to a context manually (not using a context helper):
-    # capture any context info, build a test obj, and add it to the suite
-    def self.method_added(method_name)
-      if method_name.to_s =~ Suite::TEST_METHOD_REGEX
-        klass_method_name = "#{self}##{method_name}"
-
-        if self.suite.test_methods.include?(klass_method_name)
-          puts "WARNING: redefining "#{klass_method_name}""
-          puts "  from: #{caller_locations(1,1)}"
-        else
-          self.suite.test_methods << klass_method_name
-        end
-
-        self.suite.on_test(Test.for_method(
-          method_name.to_s,
-          ContextInfo.new(self, nil, caller_locations(1,1)),
-          self.suite.config
-        ))
-      end
-    end
-
     def initialize(running_test, config, result_callback)
       @__assert_running_test__ = running_test
       @__assert_config__       = config
@@ -61,9 +44,8 @@ module Assert
       end
     end
 
-    # check if the assertion is a truthy value, if so create a new pass result,
-    # otherwise create a new fail result with the desc and what failed msg.
-    # all other assertion helpers use this one in the end
+    # Check if the result is true. If so, create a new pass result,  Otherwise
+    # create a new fail result with the desc and fail msg.
     def assert(assertion, desc = nil)
       if assertion
         pass
@@ -78,8 +60,8 @@ module Assert
       end
     end
 
-    # the opposite of assert, check if the assertion is a false value, if so create a new pass
-    # result, otherwise create a new fail result with the desc and it's what failed msg
+    # The opposite of assert. Check if the result is false. If so, create a new
+    # pass result. Otherwise create a new fail result with the desc and fail msg.
     def assert_not(assertion, fail_desc = nil)
       assert(!assertion, fail_desc) do
         "Failed assert_not: assertion was "\
@@ -88,14 +70,23 @@ module Assert
     end
     alias_method :refute, :assert_not
 
+    def assert_that(
+          actual_value = Assert::ActualValue.not_given,
+          &actual_value_block
+        )
+      Assert::ActualValue.new(actual_value, context: self, &actual_value_block)
+    end
+
     # adds a Pass result to the end of the test's results
     # does not break test execution
     def pass(pass_msg = nil)
       if @__assert_pending__ == 0
         capture_result(Assert::Result::Pass, pass_msg)
       else
-        capture_result(Assert::Result::Fail, "Pending pass (make it "\
-                                             "not pending)")
+        capture_result(
+          Assert::Result::Fail,
+          "Pending pass (make it not pending)"
+        )
       end
     end
 
@@ -157,9 +148,12 @@ module Assert
     end
 
     def subject
-      if subj = self.class.subject
-        instance_eval(&subj)
+      unless instance_variable_defined?("@__assert_subject__")
+        @__assert_subject__ =
+          instance_eval(&self.class.subject) if self.class.subject
       end
+
+      @__assert_subject__
     end
 
     def inspect

data/lib/assert/context/let_dsl.rb

@@ -0,0 +1,13 @@
+module Assert; end
+class Assert::Context; end
+module Assert::Context::LetDSL
+  def let(name, &block)
+    self.send(:define_method, name, &-> {
+      unless instance_variable_defined?("@__assert_let_#{name}__")
+        instance_variable_set("@__assert_let_#{name}__", instance_eval(&block))
+      end
+
+      instance_variable_get("@__assert_let_#{name}__")
+    })
+  end
+end

data/lib/assert/context/method_missing.rb

@@ -0,0 +1,19 @@
+require "assert/assertions"
+
+module Assert; end
+class Assert::Context; end
+module Assert::Context::MethodMissing
+  def method_missing(method, *args, &block)
+    if Assert::Assertions::IGNORED_ASSERTION_HELPERS.include?(method.to_sym)
+      ignore "The assertion `#{method}` is not supported."\
+             " Please use another assertion or the basic `assert`."
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, *)
+    Assert::Assertions::IGNORED_ASSERTION_HELPERS.include?(method.to_sym) ||
+    super
+  end
+end

data/lib/assert/context/subject_dsl.rb

@@ -1,33 +1,32 @@
 module Assert; end
-class Assert::Context
-  module SubjectDSL
-    # Add a piece of description text or return the full description for the context
-    def description(text = nil)
-      if text
-        self.descriptions << text.to_s
-      else
-        parent = self.superclass.desc if self.superclass.respond_to?(:desc)
-        own = self.descriptions
-        [parent, *own].compact.reject(&:empty?).join(" ")
-      end
+class Assert::Context; end
+module Assert::Context::SubjectDSL
+  # Add a piece of description text or return the full description for the context
+  def description(text = nil)
+    if text
+      self.descriptions << text.to_s
+    else
+      parent = self.superclass.desc if self.superclass.respond_to?(:desc)
+      own = self.descriptions
+      [parent, *own].compact.reject(&:empty?).join(" ")
     end
-    alias_method :desc, :description
-    alias_method :describe, :description
+  end
+  alias_method :desc, :description
+  alias_method :describe, :description
 
-    def subject(&block)
-      if block_given?
-        @subject = block
-      else
-        @subject || if superclass.respond_to?(:subject)
-          superclass.subject
-        end
+  def subject(&block)
+    if block_given?
+      @subject = block
+    else
+      @subject || if superclass.respond_to?(:subject)
+        superclass.subject
       end
     end
+  end
 
-    protected
+  protected
 
-    def descriptions
-      @descriptions ||= []
-    end
+  def descriptions
+    @descriptions ||= []
   end
 end

data/lib/assert/macros/methods.rb

@@ -102,28 +102,28 @@ module Assert::Macros
           self.class._methods_macro_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have instance method ##{method}"
             with_backtrace([called_from]) do
-              assert_respond_to method, subject, msg
+              assert_that(subject).responds_to(method, msg)
             end
           end
 
           self.class._methods_macro_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} does not have class method ##{method}"
             with_backtrace([called_from]) do
-              assert_respond_to method, subject.class, msg
+              assert_that(subject.class).responds_to(method, msg)
             end
           end
 
           self.class._methods_macro_not_instance_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has instance method ##{method}"
             with_backtrace([called_from]) do
-              assert_not_respond_to method, subject, msg
+              assert_that(subject).does_not_respond_to(method, msg)
             end
           end
 
           self.class._methods_macro_not_class_methods.each do |(method, called_from)|
             msg = "#{subject.class.name} has class method ##{method}"
             with_backtrace([called_from]) do
-              assert_not_respond_to method, subject.class, msg
+              assert_that(subject.class).does_not_respond_to(method, msg)
             end
           end
         end

data/lib/assert/result.rb

@@ -129,7 +129,11 @@ module Assert::Result
     end
 
     def ==(other_result)
-      self.type == other_result.type && self.message == other_result.message
+      if other_result.is_a?(self.class)
+        self.type == other_result.type && self.message == other_result.message
+      else
+        super
+      end
     end
 
     def inspect

data/lib/assert/stub.rb

@@ -9,6 +9,10 @@ module Assert
     MuchStub.stub(*args, &block)
   end
 
+  def self.stub_on_call(*args, &block)
+    MuchStub.stub_on_call(*args, &block)
+  end
+
   def self.unstub(*args)
     MuchStub.unstub(*args)
   end
@@ -26,4 +30,16 @@ module Assert
       raise err
     end
   end
+
+  def self.stub_tap(*args, &block)
+    MuchStub.tap(*args, &block)
+  end
+
+  def self.stub_tap_on_call(*args, &block)
+    MuchStub.tap_on_call(*args, &block)
+  end
+
+  def self.stub_spy(*args, &block)
+    MuchStub.spy(*args, &block)
+  end
 end

data/lib/assert/suite.rb

@@ -10,22 +10,19 @@ module Assert
   class Suite
     include Assert::ConfigHelpers
 
-    TEST_METHOD_REGEX = /^test./.freeze
-
     # A suite is a set of tests to run.  When a test class subclasses
     # the Context class, that test class is pushed to the suite.
 
-    attr_reader :config, :test_methods, :setups, :teardowns
+    attr_reader :config, :setups, :teardowns
     attr_accessor :start_time, :end_time
 
     def initialize(config)
-      @config       = config
-      @tests        = []
-      @test_methods = []
-      @setups       = []
-      @teardowns    = []
-      @start_time   = Time.now
-      @end_time     = @start_time
+      @config     = config
+      @tests      = []
+      @setups     = []
+      @teardowns  = []
+      @start_time = Time.now
+      @end_time   = @start_time
     end
 
     def suite; self; end

data/lib/assert/test.rb

@@ -20,14 +20,6 @@ module Assert
       }))
     end
 
-    def self.for_method(method_name, context_info, config)
-      self.new(self.name_file_line_context_data(context_info, method_name).merge({
-        :context_info => context_info,
-        :config       => config,
-        :code         => proc{ self.send(method_name) }
-      }))
-    end
-
     def initialize(build_data = nil)
       @build_data      = build_data || {}
       @result_callback = nil

data/lib/assert/version.rb

@@ -1,3 +1,3 @@
 module Assert
-  VERSION = "2.18.0"
+  VERSION = "2.19.0"
 end

data/test/helper.rb

@@ -9,38 +9,36 @@ $LOAD_PATH.unshift(ROOT_PATH)
 require "pry"
 require "test/support/factory"
 
-class Assert::Test
-  module TestHelpers
-    def self.included(receiver)
-      receiver.class_eval do
-        setup do
-          @test_run_results = []
-          @run_callback = proc{ |result| @test_run_results << result }
-        end
+module Assert::Test::TestHelpers
+  def self.included(receiver)
+    receiver.class_eval do
+      setup do
+        @test_run_results = []
+        @run_callback = proc { |result| @test_run_results << result }
       end
+    end
 
-      private
+    private
 
-      def test_run_callback
-        @run_callback
-      end
+    def test_run_callback
+      @run_callback
+    end
 
-      def test_run_results(type = nil)
-        return @test_run_results if type.nil?
-        @test_run_results.select{ |r| r.type == type }
-      end
+    def test_run_results(type = nil)
+      return @test_run_results if type.nil?
+      @test_run_results.select{ |r| r.type == type }
+    end
 
-      def test_run_result_count(type = nil)
-        test_run_results(type).count
-      end
+    def test_run_result_count(type = nil)
+      test_run_results(type).count
+    end
 
-      def test_run_result_messages
-        @test_run_results.map(&:message)
-      end
+    def test_run_result_messages
+      @test_run_results.map(&:message)
+    end
 
-      def last_test_run_result
-        @test_run_results.last
-      end
+    def last_test_run_result
+      @test_run_results.last
     end
   end
 end

data/test/support/factory.rb

@@ -85,4 +85,19 @@ module Factory
       instance_eval(&block) if !block.nil?
     end
   end
+
+  def self.modes_off_context(&result_block)
+    test = Factory.test
+    Factory.modes_off_context_class.new(
+      test,
+      test.config,
+      result_block || proc { |r| }
+    )
+  end
+
+  def self.backtrace
+    assert_lib_path =
+      File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+    (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
+  end
 end

data/test/system/stub_tests.rb

@@ -8,676 +8,675 @@ class Assert::Stub
 
   class InstanceTests < SystemTests
     desc "for instance methods"
+    subject { TestClass.new }
+
     setup do
-      @instance = TestClass.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class ClassTests < SystemTests
     desc "for singleton methods on a class"
+    subject { TestClass }
+
     setup do
-      @class = TestClass
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class ModuleTests < SystemTests
     desc "for singleton methods on a module"
+    subject { TestModule }
+
     setup do
-      @module = TestModule
-      Assert.stub(@module, :noargs){ "default" }
-      Assert.stub(@module, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@module, :withargs){ "default" }
-      Assert.stub(@module, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@module, :anyargs){ "default" }
-      Assert.stub(@module, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@module, :minargs){ "default" }
-      Assert.stub(@module, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@module, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@module, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @module }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class ExtendedTests < SystemTests
     desc "for extended methods"
+    subject { Class.new{ extend TestMixin } }
+
     setup do
-      @class = Class.new{ extend TestMixin }
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class IncludedTests < SystemTests
     desc "for an included method"
+    subject {
+      Class.new { include TestMixin }.new
+    }
+
     setup do
-      @class = Class.new{ include TestMixin }
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class InheritedClassTests < SystemTests
     desc "for an inherited class method"
+    subject { Class.new(TestClass) }
+
     setup do
-      @class = Class.new(TestClass)
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class InheritedInstanceTests < SystemTests
     desc "for an inherited instance method"
+    subject { Class.new(TestClass).new }
+
     setup do
-      @class = Class.new(TestClass)
-      @instance = @class.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "not allow stubbing methods with invalid arity" do
-      assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withargs).with{ } }
-      assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :minargs).with{ } }
-      assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.raises
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
 
-      assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
     end
 
     should "not allow calling methods with invalid arity" do
-      assert_raises{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.raises
 
-      assert_raises{ subject.withargs }
-      assert_raises{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.raises
+      assert_that { subject.withargs(1, 2) }.raises
 
-      assert_raises{ subject.minargs }
-      assert_raises{ subject.minargs(1) }
+      assert_that { subject.minargs }.raises
+      assert_that { subject.minargs(1) }.raises
 
-      assert_raises{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.raises
     end
   end
 
   class DelegateClassTests < SystemTests
     desc "a class that delegates another object"
+    subject { DelegateClass }
+
     setup do
-      @class = DelegateClass
-      Assert.stub(@class, :noargs){ "default" }
-      Assert.stub(@class, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@class, :withargs){ "default" }
-      Assert.stub(@class, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@class, :anyargs){ "default" }
-      Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@class, :minargs){ "default" }
-      Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@class, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @class }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_nothing_raised{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.does_not_raise
 
-      assert_nothing_raised{ subject.withargs }
-      assert_nothing_raised{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.does_not_raise
+      assert_that { subject.withargs(1, 2) }.does_not_raise
 
-      assert_nothing_raised{ subject.minargs }
-      assert_nothing_raised{ subject.minargs(1) }
+      assert_that { subject.minargs }.does_not_raise
+      assert_that { subject.minargs(1) }.does_not_raise
 
-      assert_nothing_raised{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.does_not_raise
     end
   end
 
   class DelegateInstanceTests < SystemTests
     desc "an instance that delegates another object"
+    subject { DelegateClass.new }
+
     setup do
-      @instance = DelegateClass.new
-      Assert.stub(@instance, :noargs){ "default" }
-      Assert.stub(@instance, :noargs).with{ "none" }
+      Assert.stub(subject, :noargs){ "default" }
+      Assert.stub(subject, :noargs).with{ "none" }
 
-      Assert.stub(@instance, :withargs){ "default" }
-      Assert.stub(@instance, :withargs).with(1){ "one" }
+      Assert.stub(subject, :withargs){ "default" }
+      Assert.stub(subject, :withargs).with(1){ "one" }
 
-      Assert.stub(@instance, :anyargs){ "default" }
-      Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :anyargs){ "default" }
+      Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
 
-      Assert.stub(@instance, :minargs){ "default" }
-      Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
-      Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
+      Assert.stub(subject, :minargs){ "default" }
+      Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
+      Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
 
-      Assert.stub(@instance, :withblock){ "default" }
+      Assert.stub(subject, :withblock){ "default" }
     end
-    subject{ @instance }
 
     should "allow stubbing a method that doesn't take args" do
-      assert_equal "none", subject.noargs
+      assert_that(subject.noargs).equals("none")
     end
 
     should "allow stubbing a method that takes args" do
-      assert_equal "one",     subject.withargs(1)
-      assert_equal "default", subject.withargs(2)
+      assert_that(subject.withargs(1)).equals("one")
+      assert_that(subject.withargs(2)).equals("default")
     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)
+      assert_that(subject.anyargs).equals("default")
+      assert_that(subject.anyargs(1)).equals("default")
+      assert_that(subject.anyargs(1, 2)).equals("one-two")
     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)
+      assert_that(subject.minargs(1, 2)).equals("one-two")
+      assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
+      assert_that(subject.minargs(1, 2, 4)).equals("default")
+      assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
     end
 
     should "allow stubbing a method that takes a block" do
-      assert_equal "default", subject.withblock
-      assert_equal "default", subject.withblock{ "my-block" }
+      assert_that(subject.withblock).equals("default")
+      assert_that(subject.withblock{ "my-block" }).equals("default")
     end
 
     should "allow stubbing methods with invalid arity" do
-      assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
+      assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
+      assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
+      assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
-      assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
+      assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
+      assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
 
-      assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
+      assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
     end
 
     should "allow calling methods with invalid arity" do
-      assert_nothing_raised{ subject.noargs(1) }
+      assert_that { subject.noargs(1) }.does_not_raise
 
-      assert_nothing_raised{ subject.withargs }
-      assert_nothing_raised{ subject.withargs(1, 2) }
+      assert_that { subject.withargs }.does_not_raise
+      assert_that { subject.withargs(1, 2) }.does_not_raise
 
-      assert_nothing_raised{ subject.minargs }
-      assert_nothing_raised{ subject.minargs(1) }
+      assert_that { subject.minargs }.does_not_raise
+      assert_that { subject.minargs(1) }.does_not_raise
 
-      assert_nothing_raised{ subject.withblock(1) }
+      assert_that { subject.withblock(1) }.does_not_raise
     end
   end
 
   class ParentAndChildClassTests < SystemTests
     desc "for a parent method stubbed on both the parent and child"
     setup do
-      @parent_class = Class.new
-      @child_class = Class.new(@parent_class)
-
-      Assert.stub(@parent_class, :new){ "parent" }
-      Assert.stub(@child_class, :new){ "child" }
+      Assert.stub(parent_class, :new){ "parent" }
+      Assert.stub(child_class, :new){ "child" }
     end
 
+    let(:parent_class) { Class.new }
+    let(:child_class) { Class.new(parent_class) }
+
     should "allow stubbing the methods individually" do
-      assert_equal "parent", @parent_class.new
-      assert_equal "child", @child_class.new
+      assert_that(parent_class.new).equals("parent")
+      assert_that(child_class.new).equals("child")
     end
   end