assert 2.18.3 → 2.19.3

data/test/unit/default_runner_tests.rb

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

data/test/unit/default_suite_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/default_suite"
 
@@ -6,12 +8,22 @@ require "assert/suite"
 class Assert::DefaultSuite
   class UnitTests < Assert::Context
     desc "Assert::DefaultSuite"
-    subject { suite1 }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::DefaultSuite }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new(config1) }
+
+    let(:ci1){ Factory.context_info(Factory.modes_off_context_class) }
+    let(:test1){ Factory.test(Factory.string, ci1){} }
+    let(:config1){ Factory.modes_off_config }
 
-    let(:ci1)     { Factory.context_info(Factory.modes_off_context_class) }
-    let(:test1)   { Factory.test(Factory.string, ci1) { } }
-    let(:config1) { Factory.modes_off_config }
-    let(:suite1)  { Assert::DefaultSuite.new(config1) }
+    should have_readers :test_count, :result_count, :pass_result_count
+    should have_readers :fail_result_count, :error_result_count
+    should have_readers :skip_result_count, :ignore_result_count
 
     should "be a Suite" do
       assert_that(subject).is_kind_of(Assert::Suite)

data/test/unit/factory_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/factory"
 
@@ -6,7 +8,9 @@ require "much-factory"
 module Assert::Factory
   class UnitTests < Assert::Context
     desc "Assert::Factory"
-    subject { Assert::Factory }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Factory }
 
     should "include and extend MuchFactory" do
       assert_that(subject).includes(MuchFactory)

data/test/unit/file_line_tests.rb

@@ -1,20 +1,24 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/file_line"
 
 class Assert::FileLine
   class UnitTests < Assert::Context
     desc "Assert::FileLine"
-    subject { Assert::FileLine }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::FileLine }
 
-    let(:file1) { "#{Factory.path}_tests.rb" }
-    let(:line1) { Factory.integer.to_s }
+    let(:file1){ "#{Factory.path}_tests.rb" }
+    let(:line1){ Factory.integer.to_s }
 
     should have_imeths :parse
 
     should "know how to parse and init from a file line path string" do
       file_line_path = [
         "#{file1}:#{line1}",
-        "#{file1}:#{line1} #{Factory.string}"
+        "#{file1}:#{line1} #{Factory.string}",
       ].sample
       file_line = subject.parse(file_line_path)
 
@@ -43,9 +47,7 @@ class Assert::FileLine
 
   class InitTests < UnitTests
     desc "when init"
-    subject { file_line1 }
-
-    let(:file_line1) { Assert::FileLine.new(file1, line1) }
+    subject{ unit_class.new(file1, line1) }
 
     should have_readers :file, :line
 
@@ -53,11 +55,11 @@ class Assert::FileLine
       assert_that(subject.file).equals(file1)
       assert_that(subject.line).equals(line1)
 
-      file_line = Assert::FileLine.new(file1)
+      file_line = unit_class.new(file1)
       assert_that(file_line.file).equals(file1)
       assert_that(file_line.line).equals("")
 
-      file_line = Assert::FileLine.new
+      file_line = unit_class.new
       assert_that(file_line.file).equals("")
       assert_that(file_line.line).equals("")
     end
@@ -67,11 +69,11 @@ class Assert::FileLine
     end
 
     should "know if it is equal to another file line" do
-      yes = Assert::FileLine.new(file1, line1)
-      no = Assert::FileLine.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
+      yes = unit_class.new(file1, line1)
+      no = unit_class.new("#{Factory.path}_tests.rb", Factory.integer.to_s)
 
       assert_that(subject).equals(yes)
-      assert_not_equal no,  subject
+      assert_not_equal no, subject
     end
   end
 end

data/test/unit/macro_tests.rb

@@ -1,12 +1,19 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/macro"
 
 class Assert::Macro
   class UnitTests < Assert::Context
     desc "Assert::Macro"
-    subject { macro1 }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Macro }
+  end
 
-    let(:macro1) { Assert::Macro.new {} }
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new{} }
 
     should "have an accessor for its (optional) name" do
       assert_that(subject).responds_to(:name)
@@ -14,11 +21,11 @@ class Assert::Macro
     end
 
     should "default its name if no given" do
-      assert_that((Assert::Macro.new {}).name).equals("run this macro")
+      assert_that((unit_class.new{}).name).equals("run this macro")
     end
 
     should "initialize with a given name" do
-      assert_that((Assert::Macro.new("test") {}).name).equals("test")
+      assert_that((unit_class.new("test"){}).name).equals("test")
     end
 
     should "be a Proc" do
@@ -26,7 +33,7 @@ class Assert::Macro
     end
 
     should "complain if you create a macro without a block" do
-      assert_that(-> { Assert::Macro.new }).raises(ArgumentError)
+      assert_that{ unit_class.new }.raises(ArgumentError)
     end
   end
 
@@ -34,7 +41,7 @@ class Assert::Macro
     desc "have_instance_methods macro: this class"
     subject do
       class ::InstExample
-        (1..6).each {|i| define_method("method_#{i}") {}}
+        (1..6).each{ |i| define_method("method_#{i}"){} }
       end
       ::InstExample.new
     end
@@ -55,7 +62,7 @@ class Assert::Macro
     subject do
       class ::ClassExample
         class << self
-          (1..6).each {|i| define_method("method_#{i}") {}}
+          (1..6).each{ |i| define_method("method_#{i}"){} }
         end
       end
       ::ClassExample.new
@@ -76,7 +83,7 @@ class Assert::Macro
     desc "have_readers macro: this class"
     subject do
       class ::ReaderExample
-        (1..6).each {|i| attr_reader "method_#{i}"}
+        (1..6).each{ |i| attr_reader "method_#{i}" }
       end
       ::ReaderExample.new
     end
@@ -96,7 +103,7 @@ class Assert::Macro
     desc "have_writers macro: this class"
     subject do
       class ::WriterExample
-        (1..6).each {|i| attr_writer "method_#{i}"}
+        (1..6).each{ |i| attr_writer "method_#{i}" }
       end
       ::WriterExample.new
     end
@@ -116,7 +123,7 @@ class Assert::Macro
     desc "have_accessors macro: this class"
     subject do
       class ::AccessorExample
-        (1..6).each {|i| attr_accessor "method_#{i}"}
+        (1..6).each{ |i| attr_accessor "method_#{i}" }
       end
       ::AccessorExample.new
     end

data/test/unit/result_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/result"
 
@@ -6,20 +8,23 @@ require "assert/file_line"
 module Assert::Result
   class UnitTests < Assert::Context
     desc "Assert::Result"
-    subject { Assert::Result }
+    subject{ unit_class }
+
+    let(:unit_class){ Assert::Result }
 
-    let(:test1) { Factory.test("a test name") }
+    let(:test1){ Factory.test("a test name") }
 
     should have_imeths :types, :new
 
     should "know its types" do
-      exp = {
-        :pass   => Pass,
-        :fail   => Fail,
-        :ignore => Ignore,
-        :skip   => Skip,
-        :error  => Error
-      }
+      exp =
+        {
+          pass: Pass,
+          fail: Fail,
+          ignore: Ignore,
+          skip: Skip,
+          error: Error,
+        }
       assert_that(subject.types).equals(exp)
 
       assert_that(subject.types[Factory.string]).equals(Base)
@@ -27,27 +32,26 @@ module Assert::Result
 
     should "create results from data hashes" do
       type = Assert::Result.types.keys.sample
-      exp  = Assert::Result.types[type].new(:type => type)
-      assert_that(Assert::Result.new(:type => type)).equals(exp)
+      exp  = Assert::Result.types[type].new(type: type)
+      assert_that(Assert::Result.new(type: type)).equals(exp)
     end
   end
 
-  class BaseTests < UnitTests
-    desc "Base"
-    subject { result1 }
+  class InitBaseTests < UnitTests
+    desc "Base when init"
+    subject{ Base.new(given_data1) }
 
-    let(:given_data1) {
+    let(:given_data1) do
       {
-        :type           => Factory.string,
-        :name           => Factory.string,
-        :test_name      => Factory.string,
-        :test_file_line => Assert::FileLine.new(Factory.string, Factory.integer),
-        :message        => Factory.string,
-        :output         => Factory.text,
-        :backtrace      => Backtrace.new(Factory.backtrace)
+        type: Factory.string,
+        name: Factory.string,
+        test_name: Factory.string,
+        test_file_line: Assert::FileLine.new(Factory.string, Factory.integer),
+        message: Factory.string,
+        output: Factory.text,
+        backtrace: Backtrace.new(Factory.backtrace),
       }
-    }
-    let(:result1) { Base.new(given_data1) }
+    end
 
     should have_cmeths :type, :name, :for_test
     should have_imeths :type, :name, :test_name, :test_file_line
@@ -121,10 +125,11 @@ module Assert::Result
       assert_that(subject.trace).equals(exp_trace)
 
       # test that the first bt line is used if filtered is empty
-      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
-      new_bt          = (Factory.integer(3)+1).times.map{ assert_lib_path }
-      exp_backtrace   = Backtrace.new(new_bt)
-      exp_trace       = exp_backtrace.first.to_s
+      assert_lib_path =
+        File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+      new_bt        = (Factory.integer(3) + 1).times.map{ assert_lib_path }
+      exp_backtrace = Backtrace.new(new_bt)
+      exp_trace     = exp_backtrace.first.to_s
       subject.set_backtrace(new_bt)
       assert_that(subject.backtrace).equals(exp_backtrace)
       assert_that(subject.trace).equals(exp_trace)
@@ -168,8 +173,9 @@ module Assert::Result
       assert_that(subject.line_num).equals(exp.line.to_i)
 
       # test that the first bt line is used if filtered is empty
-      assert_lib_path = File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
-      new_bt          = (Factory.integer(3)+1).times.map{ assert_lib_path }
+      assert_lib_path =
+        File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
+      new_bt = (Factory.integer(3) + 1).times.map{ assert_lib_path }
       subject.set_backtrace(new_bt)
 
       exp = new_bt.first.to_s
@@ -226,11 +232,9 @@ module Assert::Result
     end
   end
 
-  class PassTests < UnitTests
-    desc "Pass"
-    subject { result1 }
-
-    let(:result1) { Pass.new({}) }
+  class InitPassTests < UnitTests
+    desc "Pass when init"
+    subject{ Pass.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:pass)
@@ -239,11 +243,9 @@ module Assert::Result
     end
   end
 
-  class IgnoreTests < UnitTests
-    desc "Ignore"
-    subject { result1 }
-
-    let(:result1) { Ignore.new({}) }
+  class InitIgnoreTests < UnitTests
+    desc "Ignore when init"
+    subject{ Ignore.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:ignore)
@@ -252,9 +254,9 @@ module Assert::Result
     end
   end
 
-  class HaltingTestResultErrorTests < UnitTests
-    desc "HaltingTestResultError"
-    subject { HaltingTestResultError.new }
+  class InitHaltingTestResultErrorTests < UnitTests
+    desc "HaltingTestResultError when init"
+    subject{ HaltingTestResultError.new }
 
     should have_accessors :assert_with_bt
 
@@ -263,20 +265,18 @@ module Assert::Result
     end
   end
 
-  class TestFailureTests < UnitTests
-    desc "TestFailure"
-    subject { TestFailure }
+  class InitTestFailureTests < UnitTests
+    desc "TestFailure when init"
+    subject{ TestFailure.new }
 
     should "be a halting test result error" do
-      assert_that(subject.new).is_kind_of(HaltingTestResultError)
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class FailTests < UnitTests
-    desc "Fail"
-    subject { result1 }
-
-    let(:result1) { Fail.new({}) }
+  class InitFailTests < UnitTests
+    desc "Fail when init"
+    subject{ Fail.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:fail)
@@ -307,24 +307,23 @@ module Assert::Result
     end
 
     should "not allow creating for a test with non-TestFailure exceptions" do
-      assert_that(-> { Fail.for_test(test1, RuntimeError.new) }).raises(ArgumentError)
+      assert_that{ Fail.for_test(test1, RuntimeError.new) }
+        .raises(ArgumentError)
     end
   end
 
-  class TestSkippedTests < UnitTests
-    desc "TestSkipped"
-    subject { TestSkipped }
+  class InitTestSkippedTests < UnitTests
+    desc "TestSkipped when init"
+    subject{ TestSkipped.new }
 
     should "be a halting test result error" do
-      assert_that(subject.new).is_kind_of(HaltingTestResultError)
+      assert_that(subject).is_kind_of(HaltingTestResultError)
     end
   end
 
-  class SkipTests < UnitTests
-    desc "Skip"
-    subject { result1 }
-
-    let(:result1) { Skip.new({}) }
+  class InitSkipTests < UnitTests
+    desc "Skip when init"
+    subject{ Skip.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:skip)
@@ -355,15 +354,14 @@ module Assert::Result
     end
 
     should "not allow creating for a test with non-TestSkipped exceptions" do
-      assert_that(-> { Skip.for_test(test1, RuntimeError.new) }).raises(ArgumentError)
+      assert_that{ Skip.for_test(test1, RuntimeError.new) }
+        .raises(ArgumentError)
     end
   end
 
-  class ErrorTests < UnitTests
-    desc "Error"
-    subject { result1 }
-
-    let(:result1) { Error.new({}) }
+  class InitErrorTests < UnitTests
+    desc "Error when init"
+    subject{ Error.new({}) }
 
     should "know its class-level type/name" do
       assert_that(subject.class.type).equals(:error)
@@ -384,15 +382,13 @@ module Assert::Result
     end
 
     should "not allow creating for a test without an exception" do
-      assert_that(-> { Error.for_test(test1, Factory.string) }).raises(ArgumentError)
+      assert_that{ Error.for_test(test1, Factory.string) }.raises(ArgumentError)
     end
   end
 
-  class BacktraceTests < UnitTests
-    desc "Backtrace"
-    subject { backtrace1 }
-
-    let(:backtrace1) { Backtrace.new(Factory.backtrace) }
+  class InitBacktraceTests < UnitTests
+    desc "Backtrace when init"
+    subject{ Backtrace.new(Factory.backtrace) }
 
     should have_cmeths :parse, :to_s
     should have_imeths :filtered
@@ -402,7 +398,8 @@ module Assert::Result
     end
 
     should "render as a string by joining on the newline" do
-      assert_that(Backtrace.to_s(subject)).equals(subject.join(Backtrace::DELIM))
+      assert_that(Backtrace.to_s(subject))
+        .equals(subject.join(Backtrace::DELIM))
     end
 
     should "be an Array" do