assert 2.16.5 → 2.18.3

data/test/unit/assertions/assert_true_false_tests.rb

@@ -1,124 +1,122 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
-require 'assert/utils'
+require "assert/utils"
 
 module Assert::Assertions
-
   class AssertTrueTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_true`"
-    setup do
-      desc = @desc = "assert true fail desc"
-      args = @args = [ 'whatever', desc ]
-      @test = Factory.test do
+    subject { test1 }
+
+    let(:desc1) { "assert true fail desc" }
+    let(:args1) { ["whatever", desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
         assert_true(true)  # pass
         assert_true(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to be true."
-      assert_equal exp, test_run_results(:fail).first.message
-    end
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
 
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be true."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertNotTrueTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_not_true`"
-    setup do
-      desc = @desc = "assert not true fail desc"
-      args = @args = [ true, desc ]
-      @test = Factory.test do
+    subject { test1 }
+
+    let(:desc1) { "assert not true fail desc" }
+    let(:args1) { [true, desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
         assert_not_true(false) # pass
         assert_not_true(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be true."
-      assert_equal exp, test_run_results(:fail).first.message
-    end
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
 
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be true."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertFalseTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_false`"
-    setup do
-      desc = @desc = "assert false fail desc"
-      args = @args = [ 'whatever', desc ]
-      @test = Factory.test do
+    subject { test1 }
+
+    let(:desc1) { "assert false fail desc" }
+    let(:args1) { ["whatever", desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
         assert_false(false) # pass
         assert_false(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to be false."
-      assert_equal exp, test_run_results(:fail).first.message
-    end
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
 
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be false."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
 
   class AssertNotFalseTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "`assert_not_false`"
-    setup do
-      desc = @desc = "assert not false fail desc"
-      args = @args = [ false, desc ]
-      @test = Factory.test do
+    subject { test1 }
+
+    let(:desc1) { "assert not false fail desc" }
+    let(:args1) { [false, desc1] }
+    let(:test1) {
+      args = args1
+      Factory.test do
         assert_not_false(true)  # pass
         assert_not_false(*args) # fail
       end
-      @c = @test.config
-      @test.run(&test_run_callback)
-    end
-    subject{ @test }
+    }
+    let(:config1) { test1.config }
 
     should "produce results as expected" do
-      assert_equal 2, test_run_result_count
-      assert_equal 1, test_run_result_count(:pass)
-      assert_equal 1, test_run_result_count(:fail)
-    end
+      subject.run(&test_run_callback)
 
-    should "have a fail message with custom and generic explanations" do
-      exp = "#{@args[1]}\nExpected #{Assert::U.show(@args[0], @c)} to not be false."
-      assert_equal exp, test_run_results(:fail).first.message
-    end
+      assert_that(test_run_result_count).equals(2)
+      assert_that(test_run_result_count(:pass)).equals(1)
+      assert_that(test_run_result_count(:fail)).equals(1)
 
+      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be false."
+      assert_that(test_run_results(:fail).first.message).equals(exp)
+    end
   end
-
 end

data/test/unit/assertions_tests.rb

@@ -1,18 +1,16 @@
-require 'assert'
-require 'assert/assertions'
+require "assert"
+require "assert/assertions"
 
 module Assert::Assertions
-
   class UnitTests < Assert::Context
     include Assert::Test::TestHelpers
 
     desc "Assert::Context"
-    setup do
-      @context_class = Factory.modes_off_context_class
-      @test = Factory.test
-      @context = @context_class.new(@test, @test.config, proc{ |r| })
-    end
-    subject{ @context }
+    subject { context1 }
+
+    let(:context_class1) { Factory.modes_off_context_class }
+    let(:test1) { Factory.test }
+    let(:context1) { context_class1.new(test1, test1.config, proc { |r| }) }
 
     should have_imeths :assert_block, :assert_not_block, :refute_block
     should have_imeths :assert_raises, :assert_not_raises
@@ -33,27 +31,29 @@ module Assert::Assertions
     should have_imeths :assert_true, :assert_not_true, :refute_true
     should have_imeths :assert_false, :assert_not_false, :refute_false
     should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
-
   end
 
   class IgnoredTests < UnitTests
     desc "ignored assertions helpers"
     setup do
-      @tests = Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
-        context_info = Factory.context_info(@context_class)
+      tests.each{ |test| test.run(&test_run_callback) }
+    end
+
+    let(:tests) {
+      context_info = Factory.context_info(context_class1)
+      Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
         Factory.test("ignored assertion helper #{helper}", context_info) do
           self.send(helper, "doesn't matter")
         end
       end
-      @tests.each{ |test| test.run(&test_run_callback) }
-    end
+    }
 
     should "have an ignored result for each helper in the constant" do
       exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.size
-      assert_equal exp, test_run_result_count
+      assert_that(test_run_result_count).equals(exp)
 
       test_run_results.each do |result|
-        assert_kind_of Assert::Result::Ignore, result
+        assert_that(result).is_kind_of(Assert::Result::Ignore)
       end
     end
 
@@ -62,9 +62,7 @@ module Assert::Assertions
         "The assertion `#{helper}` is not supported."\
         " Please use another assertion or the basic `assert`."
       end
-      assert_equal exp, test_run_results.collect(&:message)
+      assert_that(test_run_results.collect(&:message)).equals(exp)
     end
-
   end
-
 end

data/test/unit/config_helpers_tests.rb

@@ -1,14 +1,15 @@
-require 'assert'
-require 'assert/config_helpers'
+require "assert"
+require "assert/config_helpers"
 
-require 'assert/config'
+require "assert/config"
 
 module Assert::ConfigHelpers
-
   class UnitTests < Assert::Context
     desc "Assert::ConfigHelpers"
-    setup do
-      @helpers_class = Class.new do
+    subject { helpers1 }
+
+    let(:helpers_class1) {
+      Class.new do
         include Assert::ConfigHelpers
 
         def config
@@ -17,9 +18,8 @@ module Assert::ConfigHelpers
           @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
-      @helpers = @helpers_class.new
-    end
-    subject{ @helpers }
+    }
+    let(:helpers1) { helpers_class1.new }
 
     should have_imeths :runner, :suite, :view
     should have_imeths :runner_seed, :single_test?, :single_test_file_line
@@ -35,107 +35,107 @@ module Assert::ConfigHelpers
     should have_imeths :ocurring_result_types
 
     should "know the config's runner, suite and view" do
-      assert_equal subject.config.runner, subject.runner
-      assert_equal subject.config.suite,  subject.suite
-      assert_equal subject.config.view,   subject.view
+      assert_that(subject.runner).equals(subject.config.runner)
+      assert_that(subject.suite).equals(subject.config.suite)
+      assert_that(subject.view).equals(subject.config.view)
     end
 
     should "know its runner seed" do
-      assert_equal subject.config.runner_seed, subject.runner_seed
+      assert_that(subject.runner_seed).equals(subject.config.runner_seed)
     end
 
     should "know if it is in single test mode" do
       Assert.stub(subject.config, :single_test?){ true }
-      assert_true subject.single_test?
+      assert_that(subject.single_test?).is_true
 
       Assert.stub(subject.config, :single_test?){ false }
-      assert_false subject.single_test?
+      assert_that(subject.single_test?).is_false
     end
 
     should "know its single test file line" do
       exp = subject.config.single_test_file_line
-      assert_equal exp, subject.single_test_file_line
+      assert_that(subject.single_test_file_line).equals(exp)
     end
 
     should "know its tests-to-run attrs" do
       exp = subject.config.suite.tests_to_run?
-      assert_equal exp, subject.tests_to_run?
+      assert_that(subject.tests_to_run?).equals(exp)
 
       exp = subject.config.suite.tests_to_run_count
-      assert_equal exp, subject.tests_to_run_count
+      assert_that(subject.tests_to_run_count).equals(exp)
     end
 
     should "know its test/result counts" do
       exp = subject.config.suite.test_count
-      assert_equal exp, subject.test_count
+      assert_that(subject.test_count).equals(exp)
 
       exp = subject.config.suite.result_count
-      assert_equal exp, subject.result_count
+      assert_that(subject.result_count).equals(exp)
 
       exp = subject.config.suite.pass_result_count
-      assert_equal exp, subject.pass_result_count
+      assert_that(subject.pass_result_count).equals(exp)
 
       exp = subject.config.suite.fail_result_count
-      assert_equal exp, subject.fail_result_count
+      assert_that(subject.fail_result_count).equals(exp)
 
       exp = subject.config.suite.error_result_count
-      assert_equal exp, subject.error_result_count
+      assert_that(subject.error_result_count).equals(exp)
 
       exp = subject.config.suite.skip_result_count
-      assert_equal exp, subject.skip_result_count
+      assert_that(subject.skip_result_count).equals(exp)
 
       exp = subject.config.suite.ignore_result_count
-      assert_equal exp, subject.ignore_result_count
+      assert_that(subject.ignore_result_count).equals(exp)
     end
 
     should "know if all tests are passing or not" do
       result_count = Factory.integer
       Assert.stub(subject, :result_count){ result_count }
       Assert.stub(subject, :pass_result_count){ result_count }
-      assert_true subject.all_pass?
+      assert_that(subject.all_pass?).is_true
 
       Assert.stub(subject, :pass_result_count){ Factory.integer }
-      assert_false subject.all_pass?
+      assert_that(subject.all_pass?).is_false
     end
 
     should "know its formatted run time, test rate and result rate" do
-      format = '%.6f'
+      format = "%.6f"
 
       run_time = Factory.float
       exp = format % run_time
-      assert_equal exp, subject.formatted_run_time(run_time, format)
-      assert_equal exp, subject.formatted_run_time(run_time)
+      assert_that(subject.formatted_run_time(run_time, format)).equals(exp)
+      assert_that(subject.formatted_run_time(run_time)).equals(exp)
 
       test_rate = Factory.float
       exp = format % test_rate
-      assert_equal exp, subject.formatted_result_rate(test_rate, format)
-      assert_equal exp, subject.formatted_result_rate(test_rate)
+      assert_that(subject.formatted_result_rate(test_rate, format)).equals(exp)
+      assert_that(subject.formatted_result_rate(test_rate)).equals(exp)
 
       result_rate = Factory.float
       exp = format % result_rate
-      assert_equal exp, subject.formatted_result_rate(result_rate, format)
-      assert_equal exp, subject.formatted_result_rate(result_rate)
+      assert_that(subject.formatted_result_rate(result_rate, format)).equals(exp)
+      assert_that(subject.formatted_result_rate(result_rate)).equals(exp)
     end
 
     should "know its formatted suite run time, test rate and result rate" do
-      format = '%.6f'
+      format = "%.6f"
 
       exp = format % subject.config.suite.run_time
-      assert_equal exp, subject.formatted_suite_run_time(format)
+      assert_that(subject.formatted_suite_run_time(format)).equals(exp)
 
       exp = format % subject.config.suite.test_rate
-      assert_equal exp, subject.formatted_suite_test_rate(format)
+      assert_that(subject.formatted_suite_test_rate(format)).equals(exp)
 
       exp = format % subject.config.suite.result_rate
-      assert_equal exp, subject.formatted_suite_result_rate(format)
+      assert_that(subject.formatted_suite_result_rate(format)).equals(exp)
     end
 
     should "know whether to show test profile info" do
-      assert_equal !!subject.config.profile, subject.show_test_profile_info?
+      assert_that(subject.show_test_profile_info?).equals(!!subject.config.profile)
     end
 
     should "know whether to show verbose info" do
-      assert_equal !!subject.config.verbose, subject.show_test_verbose_info?
+      assert_that(subject.show_test_verbose_info?).equals(!!subject.config.verbose)
     end
 
     should "know what result types occur in a suite's results" do
@@ -146,9 +146,7 @@ module Assert::ConfigHelpers
       exp = result_types.select do |type_sym|
         subject.send("#{type_sym}_result_count") > 0
       end
-      assert_equal exp, subject.ocurring_result_types
+      assert_that(subject.ocurring_result_types).equals(exp)
     end
-
   end
-
 end

data/test/unit/config_tests.rb

@@ -1,20 +1,18 @@
-require 'assert'
-require 'assert/config'
+require "assert"
+require "assert/config"
 
-require 'assert/default_runner'
-require 'assert/default_suite'
-require 'assert/default_view'
-require 'assert/file_line'
-require 'assert/runner'
+require "assert/default_runner"
+require "assert/default_suite"
+require "assert/default_view"
+require "assert/file_line"
+require "assert/runner"
 
 class Assert::Config
-
   class UnitTests < Assert::Context
     desc "Assert::Config"
-    setup do
-      @config = Assert::Config.new
-    end
-    subject{ @config }
+    subject { config1 }
+
+    let(:config1) { Assert::Config.new }
 
     should have_imeths :view, :suite, :runner
     should have_imeths :test_dir, :test_helper, :test_file_suffixes
@@ -26,75 +24,73 @@ class Assert::Config
     should have_imeths :single_test_file_line, :single_test_file_path
 
     should "default the view, suite, and runner" do
-      assert_kind_of Assert::DefaultView,   subject.view
-      assert_kind_of Assert::DefaultSuite,  subject.suite
-      assert_kind_of Assert::DefaultRunner, subject.runner
+      assert_that(subject.view).is_kind_of(Assert::DefaultView)
+      assert_that(subject.suite).is_kind_of(Assert::DefaultSuite)
+      assert_that(subject.runner).is_kind_of(Assert::DefaultRunner)
     end
 
     should "default the test dir/helper/suffixes" do
-      assert_equal 'test',                    subject.test_dir
-      assert_equal 'helper.rb',               subject.test_helper
-      assert_equal ['_tests.rb', "_test.rb"], subject.test_file_suffixes
+      assert_that(subject.test_dir).equals("test")
+      assert_that(subject.test_helper).equals("helper.rb")
+      assert_that(subject.test_file_suffixes).equals(["_tests.rb", "_test.rb"])
     end
 
     should "default the procs" do
-      assert_not_nil subject.changed_proc
-      assert_not_nil subject.pp_proc
-      assert_not_nil subject.use_diff_proc
-      assert_not_nil subject.run_diff_proc
+      assert_that(subject.changed_proc).is_not_nil
+      assert_that(subject.pp_proc).is_not_nil
+      assert_that(subject.use_diff_proc).is_not_nil
+      assert_that(subject.run_diff_proc).is_not_nil
     end
 
     should "default the option settings" do
-      assert_not_nil subject.runner_seed
-      assert_not     subject.changed_only
-      assert_empty   subject.changed_ref
-      assert_empty   subject.single_test
-      assert_not     subject.pp_objects
-      assert_not     subject.capture_output
-      assert         subject.halt_on_fail
-      assert_not     subject.profile
-      assert_not     subject.verbose
-      assert_not     subject.list
-      assert_not     subject.debug
+      assert_that(subject.runner_seed).is_not_nil
+      assert_that(subject.changed_only).is_false
+      assert_that(subject.changed_ref).is_empty
+      assert_that(subject.single_test).is_empty
+      assert_that(subject.pp_objects).is_false
+      assert_that(subject.capture_output).is_false
+      assert_that(subject.halt_on_fail).is_true
+      assert_that(subject.profile).is_false
+      assert_that(subject.verbose).is_false
+      assert_that(subject.list).is_false
+      assert_that(subject.debug).is_false
     end
 
     should "apply settings given from a hash" do
       assert subject.halt_on_fail
       subject.apply(:halt_on_fail => false)
-      assert_not subject.halt_on_fail
+      assert_that(subject.halt_on_fail).is_false
 
-      assert Assert::Config.new.halt_on_fail
-      assert_not Assert::Config.new(:halt_on_fail => false).halt_on_fail
+      assert_that(Assert::Config.new.halt_on_fail).is_true
+      assert_that(Assert::Config.new(:halt_on_fail => false).halt_on_fail).is_false
     end
 
     should "know if it is in single test mode" do
-      assert_false subject.single_test?
+      assert_that(subject.single_test?).is_false
 
       subject.apply(:single_test => Factory.string)
-      assert_true subject.single_test?
+      assert_that(subject.single_test?).is_true
     end
 
     should "know its single test file line" do
-      exp = Assert::FileLine.parse(File.expand_path('', Dir.pwd))
-      assert_equal exp, subject.single_test_file_line
+      exp = Assert::FileLine.parse(File.expand_path("", Dir.pwd))
+      assert_that(subject.single_test_file_line).equals(exp)
 
       file_line_path = "#{Factory.path}_tests.rb:#{Factory.integer}"
       subject.apply(:single_test => file_line_path)
 
       exp = Assert::FileLine.parse(File.expand_path(file_line_path, Dir.pwd))
-      assert_equal exp, subject.single_test_file_line
+      assert_that(subject.single_test_file_line).equals(exp)
     end
 
     should "know its single test file path" do
-      exp = Assert::FileLine.parse(File.expand_path('', Dir.pwd)).file
-      assert_equal exp, subject.single_test_file_path
+      exp = Assert::FileLine.parse(File.expand_path("", Dir.pwd)).file
+      assert_that(subject.single_test_file_path).equals(exp)
 
       path = "#{Factory.path}_tests.rb"
       file_line_path = "#{path}:#{Factory.integer}"
       subject.apply(:single_test => file_line_path)
-      assert_equal File.expand_path(path, Dir.pwd), subject.single_test_file_path
+      assert_that(subject.single_test_file_path).equals(File.expand_path(path, Dir.pwd))
     end
-
   end
-
 end