assert 2.18.3 → 2.19.3

data/test/unit/config_helpers_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/config_helpers"
 
@@ -6,20 +8,24 @@ require "assert/config"
 module Assert::ConfigHelpers
   class UnitTests < Assert::Context
     desc "Assert::ConfigHelpers"
-    subject { helpers1 }
+    subject{ unit_class }
 
-    let(:helpers_class1) {
+    let(:unit_class) do
       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
-    }
-    let(:helpers1) { helpers_class1.new }
+    end
+  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
@@ -113,7 +119,8 @@ module Assert::ConfigHelpers
 
       result_rate = Factory.float
       exp = format % result_rate
-      assert_that(subject.formatted_result_rate(result_rate, format)).equals(exp)
+      assert_that(subject.formatted_result_rate(result_rate, format))
+        .equals(exp)
       assert_that(subject.formatted_result_rate(result_rate)).equals(exp)
     end
 
@@ -131,17 +138,21 @@ module Assert::ConfigHelpers
     end
 
     should "know whether to show test profile info" do
-      assert_that(subject.show_test_profile_info?).equals(!!subject.config.profile)
+      assert_that(subject.show_test_profile_info?)
+        .equals(!!subject.config.profile)
     end
 
     should "know whether to show verbose info" do
-      assert_that(subject.show_test_verbose_info?).equals(!!subject.config.verbose)
+      assert_that(subject.show_test_verbose_info?)
+        .equals(!!subject.config.verbose)
     end
 
     should "know what result types occur in a suite's results" do
       result_types = [:pass, :fail, :ignore, :skip, :error]
       result_count = Factory.integer
-      Assert.stub(subject, "#{result_types.sample}_result_count"){ result_count }
+      Assert.stub(subject, "#{result_types.sample}_result_count") do
+        result_count
+      end
 
       exp = result_types.select do |type_sym|
         subject.send("#{type_sym}_result_count") > 0

data/test/unit/config_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/config"
 
@@ -10,9 +12,14 @@ require "assert/runner"
 class Assert::Config
   class UnitTests < Assert::Context
     desc "Assert::Config"
-    subject { config1 }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Config }
+  end
 
-    let(:config1) { Assert::Config.new }
+  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
@@ -58,17 +65,17 @@ class Assert::Config
 
     should "apply settings given from a hash" do
       assert subject.halt_on_fail
-      subject.apply(:halt_on_fail => false)
+      subject.apply(halt_on_fail: false)
       assert_that(subject.halt_on_fail).is_false
 
       assert_that(Assert::Config.new.halt_on_fail).is_true
-      assert_that(Assert::Config.new(:halt_on_fail => false).halt_on_fail).is_false
+      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_that(subject.single_test?).is_false
 
-      subject.apply(:single_test => Factory.string)
+      subject.apply(single_test: Factory.string)
       assert_that(subject.single_test?).is_true
     end
 
@@ -77,7 +84,7 @@ class Assert::Config
       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)
+      subject.apply(single_test: file_line_path)
 
       exp = Assert::FileLine.parse(File.expand_path(file_line_path, Dir.pwd))
       assert_that(subject.single_test_file_line).equals(exp)
@@ -89,8 +96,9 @@ class Assert::Config
 
       path = "#{Factory.path}_tests.rb"
       file_line_path = "#{path}:#{Factory.integer}"
-      subject.apply(:single_test => file_line_path)
-      assert_that(subject.single_test_file_path).equals(File.expand_path(path, Dir.pwd))
+      subject.apply(single_test: file_line_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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context/let_dsl"
 

data/test/unit/context/setup_dsl_tests.rb

@@ -1,13 +1,14 @@
+# 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_class1 }
+    subject{ Factory.modes_off_context_class }
 
-    let(:block1) { ::Proc.new {} }
-    let(:context_class1) { Factory.modes_off_context_class }
+    let(:block1){ ::Proc.new{} }
   end
 
   class SetupTeardownOnceMethodsTests < UnitTests
@@ -37,7 +38,7 @@ module Assert::Context::SetupDSL
   class SetupTeardownWithMethodNameTests < UnitTests
     desc "methods given a method name"
 
-    let(:method_name1) { :something_amazing }
+    let(:method_name1){ :something_amazing }
 
     should "add the method name to the context" do
       subject.setup(method_name1)
@@ -49,19 +50,28 @@ module Assert::Context::SetupDSL
   end
 
   class ParentContextClassTests < UnitTests
-    let(:parent_class1)  { Factory.modes_off_context_class }
-    let(:context_class1) { Factory.modes_off_context_class(parent_class1) }
+    subject{ Factory.modes_off_context_class(parent_class1) }
+
+    let(:parent_class1){ Factory.modes_off_context_class }
   end
 
   class SetupTeardownMultipleTests < ParentContextClassTests
     desc "with multiple calls"
 
-    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 " } }
+    let(:parent_setup_block1) do
+      ::Proc.new{ self.setup_status = "the setup" }
+    end
+    let(:parent_teardown_block1) do
+      ::Proc.new{ self.teardown_status += "the teardown" }
+    end
+    let(:context_setup_block1) do
+      ::Proc.new{ self.setup_status += " has been run" }
+    end
+    let(:context_teardown_block1) do
+      ::Proc.new{ self.teardown_status += "has been run " }
+    end
 
-    let(:test_status_class) {
+    let(:test_status_class) do
       Class.new do
         attr_accessor :setup_status, :teardown_status
         define_method(:setup_something) do
@@ -71,7 +81,7 @@ 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)
@@ -82,17 +92,19 @@ module Assert::Context::SetupDSL
       subject.teardown(&context_teardown_block1)
 
       subject.send("run_setups", obj = test_status_class.new)
-      assert_that(obj.setup_status).equals("the setup has been run with something")
+      assert_that(obj.setup_status)
+        .equals("the setup has been run with something")
 
       subject.send("run_teardowns", obj = test_status_class.new)
-      assert_that(obj.teardown_status).equals("with something has been run the teardown")
+      assert_that(obj.teardown_status)
+        .equals("with something has been run the teardown")
     end
   end
 
   class AroundMethodTests < ParentContextClassTests
     desc "with multiple `around` calls"
 
-    let(:test_status_class) { Class.new { attr_accessor :out_status } }
+    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|

data/test/unit/context/subject_dsl_tests.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context/subject_dsl"
 
 module Assert::Context::SubjectDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SubjectDSL"
-    subject { context_class1 }
+    subject{ Factory.modes_off_context_class(parent_class1) }
 
-    let(:parent_class1)  { Factory.modes_off_context_class }
-    let(:context_class1) { Factory.modes_off_context_class(parent_class1) }
-    let(:subject_block1) { Proc.new {} }
+    let(:parent_class1){ Factory.modes_off_context_class }
+    let(:subject_block1){ Proc.new{} }
   end
 
   class DescriptionTests < UnitTests

data/test/unit/context/suite_dsl_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context/suite_dsl"
 
@@ -6,11 +8,10 @@ require "assert/suite"
 module Assert::Context::SuiteDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::SuiteDSL"
-    subject { context_class1 }
+    subject{ Factory.context_class(parent_class1) }
 
-    let(:parent_class1)  { Factory.context_class }
-    let(:context_class1) { Factory.context_class(parent_class1) }
-    let(:custom_suite1)  { Factory.modes_off_suite }
+    let(:parent_class1){ Factory.context_class }
+    let(:custom_suite1){ Factory.modes_off_suite }
 
     should "use `Assert.suite` by default" do
       assert_that(subject.suite).equals(Assert.suite)
@@ -29,7 +30,7 @@ module Assert::Context::SuiteDSL
       parent_class1.suite(custom_suite1)
     end
 
-    let(:custom_suite2) { Factory.modes_off_suite }
+    let(:custom_suite2){ Factory.modes_off_suite }
 
     should "default to its parent's suite" do
       assert_that(subject.suite).equals(custom_suite1)

data/test/unit/context/test_dsl_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context/test_dsl"
 
@@ -5,8 +7,8 @@ module Assert::Context::TestDSL
   class UnitTests < Assert::Context
     desc "Assert::Context::TestDSL"
 
-    let(:test_desc1)  { "be true" }
-    let(:test_block1) { Proc.new{ assert(true) } }
+    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_desc1, test_block1
@@ -30,7 +32,8 @@ module Assert::Context::TestDSL
       assert_that(test.code).equals(test_block1)
     end
 
-    should "build a test that skips with no msg when `test_eventually` called" do
+    should "build a test that skips with no msg when `test_eventually` "\
+           "called" do
       d, b = test_desc1, test_block1
       context, test = build_eval_context{ test_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
@@ -42,7 +45,8 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "build a test that skips with no msg  when `should_eventually` called" do
+    should "build a test that skips with no msg  when `should_eventually` "\
+           "called" do
       d, b = test_desc1, test_block1
       context, test = build_eval_context{ should_eventually(d, &b) }
       err = capture_err(Assert::Result::TestSkipped) do
@@ -56,7 +60,7 @@ module Assert::Context::TestDSL
 
     should "skip with the msg \"TODO\" when `test` called with no block" do
       d = test_desc1
-      context, test = build_eval_context { test(d) } # no block passed
+      context, test = build_eval_context{ test(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
@@ -68,7 +72,7 @@ module Assert::Context::TestDSL
 
     should "skip with the msg \"TODO\" when `should` called with no block" do
       d = test_desc1
-      context, test = build_eval_context { should(d) } # no block passed
+      context, test = build_eval_context{ should(d) } # no block passed
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
@@ -78,7 +82,8 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "skip with the msg \"TODO\" when `test_eventually` called with no block" do
+    should "skip with the msg \"TODO\" when `test_eventually` called with "\
+           "no block" do
       d = test_desc1
       context, test = build_eval_context{ test_eventually(d) } # no block given
       err = capture_err(Assert::Result::TestSkipped) do
@@ -90,9 +95,10 @@ module Assert::Context::TestDSL
       assert_that(err.backtrace.size).equals(1)
     end
 
-    should "skip with the msg \"TODO\" when `should_eventually` called with no block" do
+    should "skip with the msg \"TODO\" when `should_eventually` called with "\
+           "no block" do
       d = test_desc1
-      context, test = build_eval_context{ should_eventually(d) } # no block given
+      context, test = build_eval_context{ should_eventually(d) }
       err = capture_err(Assert::Result::TestSkipped) do
         context.instance_eval(&test.code)
       end
@@ -104,7 +110,11 @@ module Assert::Context::TestDSL
 
     should "build a test from a macro using `test`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      m =
+        Assert::Macro.new do
+          test(d, &b)
+          test(d, &b)
+        end
       context_class = Factory.modes_off_context_class{ test(m) }
 
       assert_that(context_class.suite.tests_to_run_count).equals(2)
@@ -112,7 +122,11 @@ module Assert::Context::TestDSL
 
     should "build a test from a macro using `should`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      m =
+        Assert::Macro.new do
+          should(d, &b)
+          should(d, &b)
+        end
       context_class = Factory.modes_off_context_class{ should(m) }
 
       assert_that(context_class.suite.tests_to_run_count).equals(2)
@@ -120,22 +134,32 @@ module Assert::Context::TestDSL
 
     should "build a test that skips from a macro using `test_eventually`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ test(d, &b); test(d, &b) }
+      m =
+        Assert::Macro.new do
+          test(d, &b)
+          test(d, &b)
+        end
       context, test = build_eval_context{ test_eventually(m) }
 
       assert_that(context.class.suite.tests_to_run_count).equals(1)
-      assert_that(-> { context.instance_eval(&test.code) }).
-        raises(Assert::Result::TestSkipped)
+      assert_that{
+        context.instance_eval(&test.code)
+      }.raises(Assert::Result::TestSkipped)
     end
 
     should "build a test that skips from a macro using `should_eventually`" do
       d, b = test_desc1, test_block1
-      m = Assert::Macro.new{ should(d, &b); should(d, &b) }
+      m =
+        Assert::Macro.new do
+          should(d, &b)
+          should(d, &b)
+        end
       context, test = build_eval_context{ should_eventually(m) }
 
       assert_that(context.class.suite.tests_to_run_count).equals(1)
-      assert_that(-> { context.instance_eval(&test.code) }).
-        raises(Assert::Result::TestSkipped)
+      assert_that{
+        context.instance_eval(&test.code)
+      }.raises(Assert::Result::TestSkipped)
     end
 
     private
@@ -149,8 +173,8 @@ module Assert::Context::TestDSL
     def capture_err(err_class, &block)
       begin
         block.call
-      rescue err_class => e
-        e
+      rescue err_class => ex
+        ex
       end
     end
   end

data/test/unit/context_info_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/context_info"
 
@@ -6,13 +8,20 @@ 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
     end
-    subject { info1 }
 
-    let(:context1) { Assert::Context }
-    let(:info1)    { Assert::ContextInfo.new(context1, nil, @caller.first) }
+    let(:context1){ Assert::Context }
 
     should have_readers :called_from, :klass, :file
     should have_imeths :test_name