assert 2.18.2 → 2.19.2

data/test/unit/config_helpers_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/config_helpers"
 
@@ -6,19 +8,24 @@ require "assert/config"
 module Assert::ConfigHelpers
   class UnitTests < Assert::Context
     desc "Assert::ConfigHelpers"
-    setup do
-      @helpers_class = Class.new do
+    subject { unit_class }
+
+    let(:unit_class) {
+      Class.new do
         include Assert::ConfigHelpers
 
         def config
           # use the assert config since it has tests, contexts, etc
-          # also maybe use a fresh config that is empty
+          # also use a fresh config that is empty
           @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
-      @helpers = @helpers_class.new
-    end
-    subject{ @helpers }
+    }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new }
 
     should have_imeths :runner, :suite, :view
     should have_imeths :runner_seed, :single_test?, :single_test_file_line
@@ -34,67 +41,67 @@ 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.stub(subject.config, :single_test?) { true }
+      assert_that(subject.single_test?).is_true
 
-      Assert.stub(subject.config, :single_test?){ false }
-      assert_false subject.single_test?
+      Assert.stub(subject.config, :single_test?) { false }
+      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
@@ -102,39 +109,39 @@ module Assert::ConfigHelpers
 
       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"
 
       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
@@ -145,7 +152,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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/config"
 
@@ -10,10 +12,14 @@ require "assert/runner"
 class Assert::Config
   class UnitTests < Assert::Context
     desc "Assert::Config"
-    setup do
-      @config = Assert::Config.new
-    end
-    subject{ @config }
+    subject { unit_class }
+
+    let(:unit_class) { Assert::Config }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject { unit_class.new }
 
     should have_imeths :view, :suite, :runner
     should have_imeths :test_dir, :test_helper, :test_file_suffixes
@@ -25,73 +31,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
+      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
+      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

data/test/unit/context/let_dsl_tests.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "assert"
+require "assert/context/let_dsl"
+
+module Assert::Context::LetDSL
+  class UnitTests < Assert::Context
+    desc "Assert::Context::LetDSL"
+
+    # This is tested implicitly by running Assert's test suite.
+  end
+end

data/test/unit/context/setup_dsl_tests.rb

@@ -1,80 +1,70 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context/setup_dsl"
 
 module Assert::Context::SetupDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SetupDSL"
-    subject{ @context_class }
+    subject { Factory.modes_off_context_class }
+
+    let(:block1) { ::Proc.new {} }
   end
 
   class SetupTeardownOnceMethodsTests < UnitTests
     desc "once methods"
-    setup do
-      block = @block = ::Proc.new{ something_once = true }
-      @context_class = Factory.modes_off_context_class do
-        setup_once(&block)
-        teardown_once(&block)
-      end
-    end
 
     should "add the block to the suite" do
-      assert_includes @block, subject.suite.send(:setups)
-      assert_includes @block, subject.suite.send(:teardowns)
+      subject.setup_once(&block1)
+      subject.teardown_once(&block1)
+
+      assert_that(subject.suite.send(:setups)).includes(block1)
+      assert_that(subject.suite.send(:teardowns)).includes(block1)
     end
   end
 
   class SetupTeardownMethodsTests < UnitTests
     desc "methods"
-    setup do
-      block = @block = ::Proc.new{ something = true }
-      @context_class = Factory.modes_off_context_class do
-        setup(&block)
-        teardown(&block)
-      end
-    end
 
     should "add the block to the context" do
-      assert_includes @block, subject.send(:setups)
-      assert_includes @block, subject.send(:teardowns)
+      subject.setup(&block1)
+      subject.teardown(&block1)
+
+      assert_that(subject.send(:setups)).includes(block1)
+      assert_that(subject.send(:teardowns)).includes(block1)
     end
   end
 
   class SetupTeardownWithMethodNameTests < UnitTests
     desc "methods given a method name"
-    setup do
-      method_name = @method_name = :something_amazing
-      @context_class = Factory.modes_off_context_class do
-        setup(method_name)
-        teardown(method_name)
-      end
-    end
+
+    let(:method_name1) { :something_amazing }
 
     should "add the method name to the context" do
-      assert_includes @method_name, subject.send(:setups)
-      assert_includes @method_name, subject.send(:teardowns)
+      subject.setup(method_name1)
+      subject.teardown(method_name1)
+
+      assert_that(subject.send(:setups)).includes(method_name1)
+      assert_that(subject.send(:teardowns)).includes(method_name1)
     end
   end
 
-  class SetupTeardownMultipleTests < UnitTests
+  class ParentContextClassTests < UnitTests
+    subject { Factory.modes_off_context_class(parent_class1) }
+
+    let(:parent_class1)  { Factory.modes_off_context_class }
+  end
+
+  class SetupTeardownMultipleTests < ParentContextClassTests
     desc "with multiple calls"
-    setup do
-      parent_setup_block    = ::Proc.new{ self.setup_status    =  "the setup"    }
-      parent_teardown_block = ::Proc.new{ self.teardown_status += "the teardown" }
-      @parent_class = Factory.modes_off_context_class do
-        setup(&parent_setup_block)
-        teardown(&parent_teardown_block)
-      end
 
-      context_setup_block    = ::Proc.new{ self.setup_status    += " has been run" }
-      context_teardown_block = ::Proc.new{ self.teardown_status += "has been run " }
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        setup(&context_setup_block)
-        setup(:setup_something)
-        teardown(:teardown_something)
-        teardown(&context_teardown_block)
-      end
+    let(:parent_setup_block1)     { ::Proc.new { self.setup_status     = "the setup"     } }
+    let(:parent_teardown_block1)  { ::Proc.new { self.teardown_status += "the teardown"  } }
+    let(:context_setup_block1)    { ::Proc.new { self.setup_status    += " has been run" } }
+    let(:context_teardown_block1) { ::Proc.new { self.teardown_status += "has been run " } }
 
-      @test_status_class = Class.new do
+    let(:test_status_class) {
+      Class.new do
         attr_accessor :setup_status, :teardown_status
         define_method(:setup_something) do
           self.setup_status += " with something"
@@ -83,57 +73,58 @@ module Assert::Context::SetupDSL
           self.teardown_status = "with something "
         end
       end
-    end
+    }
+
+    should "run its parent and its own blocks in the correct order" do
+      parent_class1.setup(&parent_setup_block1)
+      parent_class1.teardown(&parent_teardown_block1)
+      subject.setup(&context_setup_block1)
+      subject.setup(:setup_something)
+      subject.teardown(:teardown_something)
+      subject.teardown(&context_teardown_block1)
 
-    should "run it's parent and it's own blocks in the correct order" do
-      subject.send("run_setups", obj = @test_status_class.new)
-      assert_equal "the setup has been run with something", obj.setup_status
+      subject.send("run_setups", obj = test_status_class.new)
+      assert_that(obj.setup_status).equals("the setup has been run with something")
 
-      subject.send("run_teardowns", obj = @test_status_class.new)
-      assert_equal "with something has been run the teardown", obj.teardown_status
+      subject.send("run_teardowns", obj = test_status_class.new)
+      assert_that(obj.teardown_status).equals("with something has been run the teardown")
     end
   end
 
-  class AroundMethodTests < UnitTests
+  class AroundMethodTests < ParentContextClassTests
     desc "with multiple `around` calls"
-    setup do
-      @parent_class = Factory.modes_off_context_class do
-        around do |block|
-          self.out_status ||= ""
-          self.out_status += "p-around start, "
-          block.call
-          self.out_status += "p-around end."
-        end
-      end
 
-      @context_class = Factory.modes_off_context_class(@parent_class) do
-        around do |block|
-          self.out_status += "c-around1 start, "
-          block.call
-          self.out_status += "c-around1 end, "
-        end
-        around do |block|
-          self.out_status += "c-around2 start, "
-          block.call
-          self.out_status += "c-around2 end, "
-        end
+    let(:test_status_class) { Class.new { attr_accessor :out_status } }
+
+    should "run its parent and its own blocks in the correct order" do
+      parent_class1.around do |block|
+        self.out_status ||= ""
+        self.out_status += "p-around start, "
+        block.call
+        self.out_status += "p-around end."
       end
 
-      @test_status_class = Class.new do
-        attr_accessor :out_status
+      subject.around do |block|
+        self.out_status += "c-around1 start, "
+        block.call
+        self.out_status += "c-around1 end, "
+      end
+      subject.around do |block|
+        self.out_status += "c-around2 start, "
+        block.call
+        self.out_status += "c-around2 end, "
       end
-    end
 
-    should "run it's parent and it's own blocks in the correct order" do
-      obj = @test_status_class.new
+      obj = test_status_class.new
       subject.send("run_arounds", obj) do
         obj.instance_eval{ self.out_status += "TEST, " }
       end
 
-      exp = "p-around start, c-around1 start, c-around2 start, "\
-            "TEST, "\
-            "c-around2 end, c-around1 end, p-around end."
-      assert_equal exp, obj.out_status
+      exp =
+        "p-around start, c-around1 start, c-around2 start, "\
+        "TEST, "\
+        "c-around2 end, c-around1 end, p-around end."
+      assert_that(obj.out_status).equals(exp)
     end
   end
 end