assert 2.18.0 → 2.19.0

data/test/unit/context/subject_dsl_tests.rb

@@ -2,71 +2,43 @@ require "assert"
 require "assert/context/subject_dsl"
 
 module Assert::Context::SubjectDSL
-
   class UnitTests < Assert::Context
     desc "Assert::Context::SubjectDSL"
-    subject{ @context_class }
-  end
-
-  class DescriptionsTests < UnitTests
-    desc "`descriptions` method"
-    setup do
-      descs = @descs = ["something amazing", "it really is"]
-      @context_class = Factory.modes_off_context_class do
-        descs.each{ |text| desc text }
-      end
-    end
+    subject { Factory.modes_off_context_class(parent_class1) }
 
-    should "return a collection containing any descriptions defined on the class" do
-      assert_equal @descs, subject.send(:descriptions)
-    end
+    let(:parent_class1)  { Factory.modes_off_context_class }
+    let(:subject_block1) { Proc.new {} }
   end
 
   class DescriptionTests < UnitTests
     desc "`description` method"
-    setup do
-      parent_text = @parent_desc = "parent description"
-      @parent_class = Factory.modes_off_context_class do
-        desc parent_text
-      end
-      text = @desc = "and the description for this context"
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        desc text
-      end
-    end
 
     should "return a string of all the inherited descriptions" do
-      exp_desc = "parent description and the description for this context"
-      assert_equal exp_desc, @context_class.description
+      parent_class1.desc("parent description")
+      subject.desc("and the description for this context")
+
+      exp = "parent description and the description for this context"
+      assert_that(subject.description).equals(exp)
     end
   end
 
   class SubjectFromLocalTests < UnitTests
     desc "`subject` method using local context"
-    setup do
-      subject_block = @subject_block = ::Proc.new{ @something }
-      @context_class = Factory.modes_off_context_class do
-        subject(&subject_block)
-      end
-    end
 
     should "set the subject block on the context class" do
-      assert_equal @subject_block, @context_class.subject
+      subject.subject(&subject_block1)
+
+      assert_that(subject.subject).equals(subject_block1)
     end
   end
 
   class SubjectFromParentTests < UnitTests
     desc "`subject` method using parent context"
-    setup do
-      parent_block = @parent_block = ::Proc.new{ @something }
-      @parent_class = Factory.modes_off_context_class do
-        subject(&parent_block)
-      end
-      @context_class = Factory.modes_off_context_class(@parent_class)
-    end
 
-    should "default to it's parents subject block" do
-      assert_equal @parent_block, @context_class.subject
+    should "default to its parents subject block" do
+      parent_class1.subject(&subject_block1)
+
+      assert_that(subject.subject).equals(subject_block1)
     end
   end
 end

data/test/unit/context/suite_dsl_tests.rb

@@ -6,38 +6,37 @@ require "assert/suite"
 module Assert::Context::SuiteDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SuiteDSL"
-    setup do
-      @custom_suite = Factory.modes_off_suite
-      @context_class = Factory.context_class
-    end
-    subject{ @context_class }
+    subject { Factory.context_class(parent_class1) }
+
+    let(:parent_class1)  { Factory.context_class }
+    let(:custom_suite1)  { Factory.modes_off_suite }
 
     should "use `Assert.suite` by default" do
-      assert_equal Assert.suite, subject.suite
+      assert_that(subject.suite).equals(Assert.suite)
     end
 
     should "use any given custom suite" do
-      subject.suite(@custom_suite)
-      assert_equal @custom_suite, subject.suite
+      subject.suite(custom_suite1)
+      assert_that(subject.suite).equals(custom_suite1)
     end
   end
 
   class SuiteFromParentTests < UnitTests
     desc "`suite` method using parent context"
+
     setup do
-      @parent_class = Factory.context_class
-      @parent_class.suite(@custom_suite)
-      @context_class = Factory.context_class(@parent_class)
+      parent_class1.suite(custom_suite1)
     end
 
-    should "default to it's parent's suite" do
-      assert_equal @custom_suite, subject.suite
+    let(:custom_suite2) { Factory.modes_off_suite }
+
+    should "default to its parent's suite" do
+      assert_that(subject.suite).equals(custom_suite1)
     end
 
     should "use any given custom suite" do
-      another_suite = Factory.modes_off_suite
-      subject.suite(another_suite)
-      assert_equal another_suite, subject.suite
+      subject.suite(custom_suite2)
+      assert_that(subject.suite).equals(custom_suite2)
     end
   end
 end

data/test/unit/context/test_dsl_tests.rb

@@ -4,148 +4,146 @@ require "assert/context/test_dsl"
 module Assert::Context::TestDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::TestDSL"
-    setup do
-      @test_desc = "be true"
-      @test_block = ::Proc.new{ assert(true) }
-    end
+
+    let(:test_desc1)  { "be true" }
+    let(:test_block1) { Proc.new{ assert(true) } }
 
     should "build a test using `test` with a desc and code block" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ test(d, &b) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
 
-      assert_kind_of Assert::Test, test
-      assert_equal @test_desc,  test.name
-      assert_equal @test_block, test.code
+      assert_that(test).is_kind_of(Assert::Test)
+      assert_that(test.name).equals(test_desc1)
+      assert_that(test.code).equals(test_block1)
     end
 
     should "build a test using `should` with a desc and code block" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ should(d, &b) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
 
-      assert_kind_of Assert::Test, test
-      assert_equal "should #{@test_desc}", test.name
-      assert_equal @test_block, test.code
+      assert_that(test).is_kind_of(Assert::Test)
+      assert_that(test.name).equals("should #{test_desc1}")
+      assert_that(test.code).equals(test_block1)
     end
 
     should "build a test that skips with no msg when `test_eventually` called" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "build a test that skips with no msg  when `should_eventually` called" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       context, test = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context { test(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context { should(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
-      d = @test_desc
+      d = test_desc1
       context, test = build_eval_context{ should_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
 
-      assert_equal 1,      context.class.suite.tests_to_run_count
-      assert_equal "TODO", err.message
-      assert_equal 1,      err.backtrace.size
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that(err.message).equals("TODO")
+      assert_that(err.backtrace.size).equals(1)
     end
 
     should "build a test from a macro using `test`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context_class = Factory.modes_off_context_class{ test(m) }
 
-      assert_equal 2, context_class.suite.tests_to_run_count
+      assert_that(context_class.suite.tests_to_run_count).equals(2)
     end
 
     should "build a test from a macro using `should`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context_class = Factory.modes_off_context_class{ should(m) }
 
-      assert_equal 2, context_class.suite.tests_to_run_count
+      assert_that(context_class.suite.tests_to_run_count).equals(2)
     end
 
     should "build a test that skips from a macro using `test_eventually`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ test(d, &b); test(d, &b) }
       context, test = build_eval_context{ test_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
-      assert_raises(Assert::Result::TestSkipped) do
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that {
         context.instance_eval(&test.code)
-      end
+      }.raises(Assert::Result::TestSkipped)
     end
 
     should "build a test that skips from a macro using `should_eventually`" do
-      d, b = @test_desc, @test_block
+      d, b = test_desc1, test_block1
       m = Assert::Macro.new{ should(d, &b); should(d, &b) }
       context, test = build_eval_context{ should_eventually(m) }
 
-      assert_equal 1, context.class.suite.tests_to_run_count
-      assert_raises(Assert::Result::TestSkipped) do
+      assert_that(context.class.suite.tests_to_run_count).equals(1)
+      assert_that {
         context.instance_eval(&test.code)
-      end
-
+      }.raises(Assert::Result::TestSkipped)
     end
 
     private
 
     def build_eval_context(&build_block)
-      context_class = Factory.modes_off_context_class &build_block
+      context_class = Factory.modes_off_context_class(&build_block)
       test = context_class.suite.sorted_tests_to_run.to_a.last
       [context_class.new(test, test.config, proc{ |r| }), test]
     end

data/test/unit/context_info_tests.rb

@@ -6,47 +6,55 @@ require "assert/context"
 class Assert::ContextInfo
   class UnitTests < Assert::Context
     desc "Assert::ContextInfo"
+    subject { unit_class }
+
+    let(:unit_class) { Assert::ContextInfo }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new(context1, nil, @caller.first) }
+
     setup do
       @caller = caller
-      @klass  = Assert::Context
-      @info   = Assert::ContextInfo.new(@klass, nil, @caller.first)
     end
-    subject{ @info }
+
+    let(:context1) { Assert::Context }
 
     should have_readers :called_from, :klass, :file
     should have_imeths :test_name
 
     should "set its klass on init" do
-      assert_equal @klass, subject.klass
+      assert_that(subject.klass).equals(context1)
     end
 
     should "set its called_from to the called_from or first caller on init" do
-      info = Assert::ContextInfo.new(@klass, @caller.first, nil)
-      assert_equal @caller.first, info.called_from
+      info = Assert::ContextInfo.new(context1, @caller.first, nil)
+      assert_that(info.called_from).equals(@caller.first)
 
-      info = Assert::ContextInfo.new(@klass, nil, @caller.first)
-      assert_equal @caller.first, info.called_from
+      info = Assert::ContextInfo.new(context1, nil, @caller.first)
+      assert_that(info.called_from).equals(@caller.first)
     end
 
     should "set its file from caller info on init" do
-      assert_equal @caller.first.gsub(/\:[0-9]+.*$/, ""), subject.file
+      assert_that(subject.file).equals(@caller.first.gsub(/\:[0-9]+.*$/, ""))
     end
 
     should "not have any file info if no caller is given" do
-      info = Assert::ContextInfo.new(@klass)
-      assert_nil info.file
+      info = Assert::ContextInfo.new(context1)
+      assert_that(info.file).is_nil
     end
 
     should "know how to build the contextual test name for a given name" do
       desc = Factory.string
       name = Factory.string
 
-      assert_equal name, subject.test_name(name)
-      assert_equal "",   subject.test_name("")
-      assert_equal "",   subject.test_name(nil)
+      assert_that(subject.test_name(name)).equals(name)
+      assert_that(subject.test_name("")).equals("")
+      assert_that(subject.test_name(nil)).equals("")
 
       Assert.stub(subject.klass, :description){ desc }
-      assert_equal "#{desc} #{name}", subject.test_name(name)
+      assert_that(subject.test_name(name)).equals("#{desc} #{name}")
     end
   end
 end

data/test/unit/context_tests.rb

@@ -8,345 +8,353 @@ require "assert/utils"
 class Assert::Context
   class UnitTests < Assert::Context
     desc "Assert::Context"
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Context }
+
+    # DSL methods
+    should have_imeths :description, :desc, :describe, :subject, :suite, :let
+    should have_imeths :setup_once, :before_once, :startup
+    should have_imeths :teardown_once, :after_once, :shutdown
+    should have_imeths :setup, :before, :setups, :run_setups
+    should have_imeths :teardown, :after, :teardowns, :run_teardowns
+    should have_imeths :around, :arounds, :run_arounds
+    should have_imeths :test, :test_eventually, :test_skip
+    should have_imeths :should, :should_eventually, :should_skip
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { context_class1.new(test1, test1.config, result_callback1) }
+
     setup do
-      @test = Factory.test
-      @context_class = @test.context_class
       @callback_result = nil
-      @test_results = []
-      @result_callback = proc do |result|
-        @callback_result = result
-        @test_results << result
-      end
-      @context = @context_class.new(@test, @test.config, @result_callback)
     end
-    subject{ @context }
 
-    # DSL methods
-    should have_cmeths :description, :desc, :describe, :subject, :suite
-    should have_cmeths :setup_once, :before_once, :startup
-    should have_cmeths :teardown_once, :after_once, :shutdown
-    should have_cmeths :setup, :before, :setups, :run_setups
-    should have_cmeths :teardown, :after, :teardowns, :run_teardowns
-    should have_cmeths :around, :arounds, :run_arounds
-    should have_cmeths :test, :test_eventually, :test_skip
-    should have_cmeths :should, :should_eventually, :should_skip
-
-    should have_imeths :assert, :assert_not, :refute
+    let(:test1)            { Factory.test }
+    let(:context_class1)   { test1.context_class }
+    let(:test_results1)    { [] }
+    let(:result_callback1) {
+      proc { |result| @callback_result = result; test_results1 << result }
+    }
+    let(:halt_config1) { Assert::Config.new(:halt_on_fail => true) }
+    let(:msg1) { Factory.string }
+
+    should have_imeths :assert, :assert_not, :refute, :assert_that
     should have_imeths :pass, :ignore, :fail, :flunk, :skip
     should have_imeths :pending, :with_backtrace, :subject
 
     should "collect context info" do
       test = @__assert_running_test__
-      assert_match(/test\/unit\/context_tests.rb$/, test.context_info.file)
-      assert_equal self.class, test.context_info.klass
+      assert_that(test.context_info.file).matches(/test\/unit\/context_tests.rb$/)
+      assert_that(test.context_info.klass).equals(self.class)
     end
+
     private
 
     ASSERT_TEST_PATH_REGEX = /\A#{File.join(ROOT_PATH, "test", "")}/
 
     def assert_with_bt_set(exp_with_bt, result)
       with_backtrace(caller) do
-        assert_true result.with_bt_set?
+        assert_that(result.with_bt_set?).is_true
 
         exp = Assert::Result::Backtrace.to_s(exp_with_bt+[(result.backtrace.filtered.first)])
-        assert_equal exp,               result.trace
-        assert_equal exp_with_bt.first, result.src_line
+        assert_that(result.trace).equals(exp)
+        assert_that(result.src_line).equals(exp_with_bt.first)
       end
     end
 
     def assert_not_with_bt_set(result)
       with_backtrace(caller) do
-        assert_false result.with_bt_set?
+        assert_that(result.with_bt_set?).is_false
 
-        assert_equal result.src_line,                      result.trace
-        assert_equal result.backtrace.filtered.first.to_s, result.src_line
+        assert_that(result.trace).equals(result.src_line)
+        assert_that(result.src_line).equals(result.backtrace.filtered.first.to_s)
       end
     end
   end
 
-  class SkipTests < UnitTests
+  class SkipTests < InitTests
     desc "skip method"
+
     setup do
-      @skip_msg = "I need to implement this in the future."
-      begin; @context.skip(@skip_msg); rescue StandardError => @exception; end
+      begin; subject.skip(msg1); rescue StandardError => @exception; end
       @result = Factory.skip_result(@exception)
     end
-    subject{ @result }
 
     should "raise a test skipped exception and set its message" do
-      assert_kind_of Assert::Result::TestSkipped, @exception
-      assert_equal @skip_msg, @exception.message
-      assert_equal @skip_msg, subject.message
+      assert_that(@exception).is_kind_of(Assert::Result::TestSkipped)
+      assert_that(@exception.message).equals(msg1)
+      assert_that(@result.message).equals(msg1)
     end
 
     should "not call the result callback" do
-      assert_nil @callback_result
+      assert_that(@callback_result).is_nil
     end
 
     should "use any given called from arg as the exception backtrace" do
-      assert_not_equal 1, @exception.backtrace.size
+      assert_that(@exception.backtrace.size).does_not_equal(1)
 
       called_from = Factory.string
-      begin; @context.skip(@skip_msg, called_from); rescue StandardError => exception; end
-      assert_equal 1,           exception.backtrace.size
-      assert_equal called_from, exception.backtrace.first
+      begin; subject.skip(msg1, called_from); rescue StandardError => exception; end
+      assert_that(exception.backtrace.size).equals(1)
+      assert_that(exception.backtrace.first).equals(called_from)
     end
   end
 
-  class IgnoreTests < UnitTests
+  class IgnoreTests < InitTests
     desc "ignore method"
+
     setup do
-      @ignore_msg = "Ignore this for now, will do later."
-      @result = @context.ignore(@ignore_msg)
+      @result = subject.ignore(msg1)
     end
-    subject{ @result }
 
     should "create an ignore result and set its message" do
-      assert_kind_of Assert::Result::Ignore, subject
-      assert_equal @ignore_msg, subject.message
+      assert_that(@result).is_kind_of(Assert::Result::Ignore)
+      assert_that(@result.message).equals(msg1)
     end
 
     should "call the result callback" do
-      assert_equal @result, @callback_result
+      assert_that(@callback_result).equals(@result)
     end
   end
 
-  class PassTests < UnitTests
+  class PassTests < InitTests
     desc "pass method"
+
     setup do
-      @pass_msg = "That's right, it works."
-      @result = @context.pass(@pass_msg)
+      @result = subject.pass(msg1)
     end
-    subject{ @result }
 
     should "create a pass result and set its message" do
-      assert_kind_of Assert::Result::Pass, subject
-      assert_equal @pass_msg, subject.message
+      assert_that(@result).is_kind_of(Assert::Result::Pass)
+      assert_that(@result.message).equals(msg1)
     end
 
     should "call the result callback" do
-      assert_equal @result, @callback_result
+      assert_that(@callback_result).equals(@result)
     end
   end
 
-  class FlunkTests < UnitTests
+  class FlunkTests < InitTests
     desc "flunk method"
+
     setup do
-      @flunk_msg = "It flunked."
-      @result = @context.flunk(@flunk_msg)
+      @result = subject.flunk(msg1)
     end
-    subject{ @result }
 
     should "create a fail result and set its message" do
-      assert_kind_of Assert::Result::Fail, subject
-      assert_equal @flunk_msg, subject.message
+      assert_that(@result).is_kind_of(Assert::Result::Fail)
+      assert_that(@result.message).equals(msg1)
     end
 
     should "call the result callback" do
-      assert_equal @result, @callback_result
+      assert_that(@callback_result).equals(@result)
     end
   end
 
-  class FailTests < UnitTests
+  class FailTests < InitTests
     desc "fail method"
+
     setup do
-      @result = @context.fail
+      @result = subject.fail
     end
-    subject{ @result }
 
     should "create a fail result and set its backtrace" do
-      assert_kind_of Assert::Result::Fail, subject
-      assert_equal subject.backtrace.filtered.first.to_s, subject.trace
-      assert_kind_of Array, subject.backtrace
+      assert_that(@result).is_kind_of(Assert::Result::Fail)
+      assert_that(@result.trace).equals(@result.backtrace.filtered.first.to_s)
+      assert_that(@result.backtrace).is_kind_of(Array)
     end
 
     should "set any given result message" do
-      fail_msg = "Didn't work"
-      result = @context.fail(fail_msg)
-      assert_equal fail_msg, result.message
+      result = subject.fail(msg1)
+      assert_that(result.message).equals(msg1)
     end
 
     should "call the result callback" do
-      assert_equal @result, @callback_result
+      assert_that(@callback_result).equals(@result)
     end
   end
 
-  class HaltOnFailTests < UnitTests
+  class HaltOnFailTests < InitTests
     desc "failing when halting on fails"
-    setup do
-      @halt_config = Assert::Config.new(:halt_on_fail => true)
-      @context = @context_class.new(@test, @halt_config, @result_callback)
-      @fail_msg = "something failed"
-    end
-    subject{ @result }
+    subject { context_class1.new(test1, halt_config1, result_callback1) }
 
     should "raise an exception with the failure's message" do
-      begin; @context.fail(@fail_msg); rescue StandardError => err; end
-      assert_kind_of Assert::Result::TestFailure, err
-      assert_equal @fail_msg, err.message
+      begin; subject.fail(msg1); rescue StandardError => err; end
+      assert_that(err).is_kind_of(Assert::Result::TestFailure)
+      assert_that(err.message).equals(msg1)
 
       result = Assert::Result::Fail.for_test(Factory.test("something"), err)
-      assert_equal @fail_msg, result.message
+      assert_that(result.message).equals(msg1)
     end
 
     should "not call the result callback" do
-      assert_nil @callback_result
+      assert_that(@callback_result).is_nil
     end
   end
 
-  class AssertTests < UnitTests
+  class AssertTests < InitTests
     desc "assert method"
-    setup do
-      @fail_desc = "my fail desc"
-      @what_failed = "what failed"
-    end
+
+    let(:what_failed) { Factory.string }
 
     should "return a pass result given a `true` assertion" do
-      result = subject.assert(true, @fail_desc){ @what_failed }
-      assert_kind_of Assert::Result::Pass, result
-      assert_equal "", result.message
+      result = subject.assert(true, msg1){ what_failed }
+      assert_that(result).is_kind_of(Assert::Result::Pass)
+      assert_that(result.message).equals("")
     end
 
     should "return a fail result given a `false` assertion" do
-      result = subject.assert(false, @fail_desc){ @what_failed }
-      assert_kind_of Assert::Result::Fail, result
+      result = subject.assert(false, msg1){ what_failed }
+      assert_that(result).is_kind_of(Assert::Result::Fail)
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_def_what = "Failed assert: assertion was `#{Assert::U.show(false, @test.config)}`."
-      result = subject.assert(false, @fail_desc)
+      exp_def_what = "Failed assert: assertion was `#{Assert::U.show(false, test1.config)}`."
+      result = subject.assert(false, msg1)
 
-      assert_equal [@fail_desc, exp_def_what].join("\n"), result.message
+      assert_that(result.message).equals([msg1, exp_def_what].join("\n"))
     end
 
     should "use a custom fail message if one is given" do
-      result = subject.assert(false, @fail_desc){ @what_failed }
-      assert_equal [@fail_desc, @what_failed].join("\n"), result.message
+      result = subject.assert(false, msg1){ what_failed }
+      assert_that(result.message).equals([msg1, what_failed].join("\n"))
     end
 
     should "return a pass result given a \"truthy\" assertion" do
-      assert_kind_of Assert::Result::Pass, subject.assert(34)
+      assert_that(subject.assert(34)).is_kind_of(Assert::Result::Pass)
     end
 
     should "return a fail result gievn a `nil` assertion" do
-      assert_kind_of Assert::Result::Fail, subject.assert(nil)
+      assert_that(subject.assert(nil)).is_kind_of(Assert::Result::Fail)
     end
   end
 
-  class AssertNotTests < UnitTests
+  class AssertNotTests < InitTests
     desc "assert_not method"
-    setup do
-      @fail_desc = "my fail desc"
-    end
 
     should "return a pass result given a `false` assertion" do
-      result = subject.assert_not(false, @fail_desc)
-      assert_kind_of Assert::Result::Pass, result
-      assert_equal "", result.message
+      result = subject.assert_not(false, msg1)
+      assert_that(result).is_kind_of(Assert::Result::Pass)
+      assert_that(result.message).equals("")
     end
 
     should "return a fail result given a `true` assertion" do
-      result = subject.assert_not(true, @fail_desc)
-      assert_kind_of Assert::Result::Fail, result
+      result = subject.assert_not(true, msg1)
+      assert_that(result).is_kind_of(Assert::Result::Fail)
     end
 
     should "pp the assertion value in the fail message by default" do
-      exp_def_what = "Failed assert_not: assertion was `#{Assert::U.show(true, @test.config)}`."
-      result = subject.assert_not(true, @fail_desc)
+      exp_def_what = "Failed assert_not: assertion was `#{Assert::U.show(true, test1.config)}`."
+      result = subject.assert_not(true, msg1)
 
-      assert_equal [@fail_desc, exp_def_what].join("\n"), result.message
+      assert_that(result.message).equals([msg1, exp_def_what].join("\n"))
     end
 
     should "return a fail result given a \"truthy\" assertion" do
-      assert_kind_of Assert::Result::Fail, subject.assert_not(34)
+      assert_that(subject.assert_not(34)).is_kind_of(Assert::Result::Fail)
     end
 
     should "return a pass result given a `nil` assertion" do
-      assert_kind_of Assert::Result::Pass, subject.assert_not(nil)
+      assert_that(subject.assert_not(nil)).is_kind_of(Assert::Result::Pass)
     end
   end
 
-  class SubjectTests < UnitTests
+  class AssertThatTests < InitTests
+    desc "`assert_that` method"
+
+    setup do
+      Assert.stub_tap_on_call(Assert::ActualValue, :new) { |_, call|
+        @actual_value_new_call = call
+      }
+    end
+
+    let(:actual_value) { Factory.string }
+
+    should "build an Assert::ActualValue" do
+      assert_instance_of Assert::ActualValue, subject.assert_that(actual_value)
+      assert_equal [actual_value], @actual_value_new_call.pargs
+      assert_equal({ context: subject },  @actual_value_new_call.kargs)
+    end
+  end
+
+  class SubjectTests < InitTests
     desc "subject method"
+    subject { context_class1.new(test1, test1.config, proc{ |result| }) }
+
     setup do
-      expected = @expected = "amazing"
-      @context_class = Factory.modes_off_context_class do
-        subject{ @something = expected }
-      end
-      @context = @context_class.new(@test, @test.config, proc{ |result| })
-      @subject = @context.subject
+      expected = expected1
+      context_class1.subject { @something = expected }
+      @subject = subject.subject
     end
-    subject{ @subject }
+
+    let(:context_class1) { Factory.modes_off_context_class }
+    let(:expected1) { Factory.string }
 
     should "instance evaluate the block set with the class setup method" do
-      assert_equal @expected, subject
+      assert_that(@subject).equals(expected1)
     end
   end
 
-  class PendingTests < UnitTests
+  class PendingTests < InitTests
     desc "`pending` method"
-    setup do
-      block2  = proc { fail; pass; }
-      @block1 = proc { pending(&block2) } # test nesting
-    end
+
+    let(:block2) { proc { fail; pass; } }
+    let(:block1) { block = block2; proc { pending(&block) } } # test nesting
 
     should "make fails skips and make passes fails" do
-      @context.fail "not affected"
-      @context.pass
-      @context.pending(&@block1)
+      subject.fail "not affected"
+      subject.pass
+      subject.pending(&block1)
 
-      assert_equal 4, @test_results.size
-      norm_fail, norm_pass, pending_fail, pending_pass = @test_results
+      assert_that(test_results1.size).equals(4)
+      norm_fail, norm_pass, pending_fail, pending_pass = test_results1
 
-      assert_kind_of Assert::Result::Fail, norm_fail
-      assert_kind_of Assert::Result::Pass, norm_pass
+      assert_that(norm_fail).is_kind_of(Assert::Result::Fail)
+      assert_that(norm_pass).is_kind_of(Assert::Result::Pass)
 
-      assert_kind_of Assert::Result::Skip, pending_fail
-      assert_includes "Pending fail", pending_fail.message
+      assert_that(pending_fail).is_kind_of(Assert::Result::Skip)
+      assert_that(pending_fail.message).includes("Pending fail")
 
-      assert_kind_of Assert::Result::Fail, pending_pass
-      assert_includes "Pending pass", pending_pass.message
+      assert_that(pending_pass).is_kind_of(Assert::Result::Fail)
+      assert_that(pending_pass.message).includes("Pending pass")
     end
   end
 
   class PendingWithHaltOnFailTests < PendingTests
     desc "when halting on fails"
-    setup do
-      @halt_config = Assert::Config.new(:halt_on_fail => true)
-      @context = @context_class.new(@test, @halt_config, @result_callback)
-    end
-    subject{ @result }
+    subject { context_class1.new(test1, halt_config1, result_callback1) }
 
     should "make fails skips and stop the test" do
-      begin; @context.pending(&@block1); rescue StandardError => err; end
-      assert_kind_of Assert::Result::TestSkipped, err
-      assert_includes "Pending fail", err.message
+      begin; subject.pending(&block1); rescue StandardError => err; end
+      assert_that(err).is_kind_of(Assert::Result::TestSkipped)
+      assert_that(err.message).includes("Pending fail")
 
-      assert_equal 0, @test_results.size # it halted before the pending pass
+      assert_that(test_results1.size).equals(0) # it halted before the pending pass
     end
   end
 
-  class WithBacktraceTests < UnitTests
+  class WithBacktraceTests < InitTests
     desc "`with_backtrace` method"
-    setup do
-      @from_bt    = ["called_from_here", Factory.string]
-      @from_block = proc { ignore; fail; pass; skip "todo"; }
-    end
+
+    let(:from_bt1)    { ["called_from_here", Factory.string] }
+    let(:from_block1) { proc { ignore; fail; pass; skip "todo"; } }
 
     should "alter non-error block results' bt with given bt's first line" do
-      @context.fail "not affected"
+      subject.fail "not affected"
       begin
-        @context.with_backtrace(@from_bt, &@from_block)
+        subject.with_backtrace(from_bt1, &from_block1)
       rescue Assert::Result::TestSkipped => e
-        @test_results << Assert::Result::Skip.for_test(@test, e)
+        test_results1 << Assert::Result::Skip.for_test(test1, e)
       end
 
-      assert_equal 5, @test_results.size
-      norm_fail, with_ignore, with_fail, with_pass, _with_skip = @test_results
+      assert_that(test_results1.size).equals(5)
+      norm_fail, with_ignore, with_fail, with_pass, _with_skip = test_results1
 
       assert_not_with_bt_set norm_fail
 
-      exp = [@from_bt.first]
+      exp = [from_bt1.first]
       assert_with_bt_set exp, with_ignore
       assert_with_bt_set exp, with_fail
       assert_with_bt_set exp, with_pass
@@ -354,30 +362,32 @@ class Assert::Context
     end
   end
 
-  class WithNestedBacktraceTests < UnitTests
+  class WithNestedBacktraceTests < InitTests
     desc "`with_backtrace` method nested"
-    setup do
-      @from_bt1            = ["called_from_here 1", Factory.string]
-      @from_bt2 = from_bt2 = ["called_from_here 2", Factory.string]
 
-      from_block2  = proc { ignore; fail; pass; skip "todo"; }
-      @from_block1 = proc { with_backtrace(from_bt2, &from_block2) }
-    end
+    let(:from_bt1)    { ["called_from_here 1", Factory.string] }
+    let(:from_bt2)    { ["called_from_here 2", Factory.string] }
+    let(:from_block2) { proc { ignore; fail; pass; skip "todo"; } }
+    let(:from_block1) {
+      from_bt    = from_bt2
+      from_block = from_block2
+      proc { with_backtrace(from_bt, &from_block) }
+    }
 
     should "alter non-error block results' bt with nested wbt accrued first lines" do
-      @context.fail "not affected"
+      subject.fail "not affected"
       begin
-        @context.with_backtrace(@from_bt1, &@from_block1)
+        subject.with_backtrace(from_bt1, &from_block1)
       rescue Assert::Result::TestSkipped => e
-        @test_results << Assert::Result::Skip.for_test(@test, e)
+        test_results1 << Assert::Result::Skip.for_test(test1, e)
       end
 
-      assert_equal 5, @test_results.size
-      norm_fail, with_ignore, with_fail, with_pass, with_skip = @test_results
+      assert_that(test_results1.size).equals(5)
+      norm_fail, with_ignore, with_fail, with_pass, _with_skip = test_results1
 
       assert_not_with_bt_set norm_fail
 
-      exp = [@from_bt1.first, @from_bt2.first]
+      exp = [from_bt1.first, from_bt2.first]
       assert_with_bt_set exp, with_ignore
       assert_with_bt_set exp, with_fail
       assert_with_bt_set exp, with_pass
@@ -385,16 +395,11 @@ class Assert::Context
     end
   end
 
-  class InspectTests < UnitTests
+  class InspectTests < InitTests
     desc "inspect method"
-    setup do
-      @expected = "#<#{@context.class}>"
-      @inspect = @context.inspect
-    end
-    subject{ @inspect }
 
     should "just show the name of the class" do
-      assert_equal @expected, subject
+      assert_that(subject.inspect).equals("#<#{subject.class}>")
     end
   end
 end