assert 2.19.1 → 2.19.6

data/test/unit/default_suite_tests.rb

@@ -8,18 +8,22 @@ require "assert/suite"
 class Assert::DefaultSuite
   class UnitTests < Assert::Context
     desc "Assert::DefaultSuite"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::DefaultSuite }
+    let(:unit_class){ Assert::DefaultSuite }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(config1) }
+    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 }
+
+    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

@@ -8,9 +8,9 @@ require "much-factory"
 module Assert::Factory
   class UnitTests < Assert::Context
     desc "Assert::Factory"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Factory }
+    let(:unit_class){ Assert::Factory }
 
     should "include and extend MuchFactory" do
       assert_that(subject).includes(MuchFactory)

data/test/unit/file_line_tests.rb

@@ -6,19 +6,19 @@ require "assert/file_line"
 class Assert::FileLine
   class UnitTests < Assert::Context
     desc "Assert::FileLine"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::FileLine }
+    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)
 
@@ -47,7 +47,7 @@ class Assert::FileLine
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(file1, line1) }
+    subject{ unit_class.new(file1, line1) }
 
     should have_readers :file, :line
 
@@ -73,7 +73,7 @@ class Assert::FileLine
       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

@@ -6,14 +6,14 @@ require "assert/macro"
 class Assert::Macro
   class UnitTests < Assert::Context
     desc "Assert::Macro"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Macro }
+    let(:unit_class){ Assert::Macro }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new {} }
+    subject{ unit_class.new{} }
 
     should "have an accessor for its (optional) name" do
       assert_that(subject).responds_to(:name)
@@ -21,11 +21,11 @@ class Assert::Macro
     end
 
     should "default its name if no given" do
-      assert_that((unit_class.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((unit_class.new("test") {}).name).equals("test")
+      assert_that((unit_class.new("test"){}).name).equals("test")
     end
 
     should "be a Proc" do
@@ -33,7 +33,7 @@ class Assert::Macro
     end
 
     should "complain if you create a macro without a block" do
-      assert_that { unit_class.new }.raises(ArgumentError)
+      assert_that{ unit_class.new }.raises(ArgumentError)
     end
   end
 
@@ -41,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
@@ -62,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
@@ -83,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
@@ -103,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
@@ -123,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

@@ -8,22 +8,23 @@ require "assert/file_line"
 module Assert::Result
   class UnitTests < Assert::Context
     desc "Assert::Result"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Result }
+    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)
@@ -31,26 +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 InitBaseTests < UnitTests
     desc "Base when init"
-    subject { Base.new(given_data1) }
+    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),
       }
-    }
+    end
 
     should have_cmeths :type, :name, :for_test
     should have_imeths :type, :name, :test_name, :test_file_line
@@ -124,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)
@@ -171,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
@@ -231,7 +234,7 @@ module Assert::Result
 
   class InitPassTests < UnitTests
     desc "Pass when init"
-    subject { Pass.new({}) }
+    subject{ Pass.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:pass)
@@ -242,7 +245,7 @@ module Assert::Result
 
   class InitIgnoreTests < UnitTests
     desc "Ignore when init"
-    subject { Ignore.new({}) }
+    subject{ Ignore.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:ignore)
@@ -253,7 +256,7 @@ module Assert::Result
 
   class InitHaltingTestResultErrorTests < UnitTests
     desc "HaltingTestResultError when init"
-    subject { HaltingTestResultError.new }
+    subject{ HaltingTestResultError.new }
 
     should have_accessors :assert_with_bt
 
@@ -264,7 +267,7 @@ module Assert::Result
 
   class InitTestFailureTests < UnitTests
     desc "TestFailure when init"
-    subject { TestFailure.new }
+    subject{ TestFailure.new }
 
     should "be a halting test result error" do
       assert_that(subject).is_kind_of(HaltingTestResultError)
@@ -273,7 +276,7 @@ module Assert::Result
 
   class InitFailTests < UnitTests
     desc "Fail when init"
-    subject { Fail.new({}) }
+    subject{ Fail.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:fail)
@@ -304,13 +307,14 @@ 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 InitTestSkippedTests < UnitTests
     desc "TestSkipped when init"
-    subject { TestSkipped.new }
+    subject{ TestSkipped.new }
 
     should "be a halting test result error" do
       assert_that(subject).is_kind_of(HaltingTestResultError)
@@ -319,7 +323,7 @@ module Assert::Result
 
   class InitSkipTests < UnitTests
     desc "Skip when init"
-    subject { Skip.new({}) }
+    subject{ Skip.new({}) }
 
     should "know its type/name" do
       assert_that(subject.type).equals(:skip)
@@ -350,13 +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 InitErrorTests < UnitTests
     desc "Error when init"
-    subject { Error.new({}) }
+    subject{ Error.new({}) }
 
     should "know its class-level type/name" do
       assert_that(subject.class.type).equals(:error)
@@ -377,13 +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 InitBacktraceTests < UnitTests
     desc "Backtrace when init"
-    subject { Backtrace.new(Factory.backtrace) }
+    subject{ Backtrace.new(Factory.backtrace) }
 
     should have_cmeths :parse, :to_s
     should have_imeths :filtered
@@ -393,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

data/test/unit/runner_tests.rb

@@ -12,9 +12,9 @@ require "assert/view"
 class Assert::Runner
   class UnitTests < Assert::Context
     desc "Assert::Runner"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Runner }
+    let(:unit_class){ Assert::Runner }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
@@ -23,14 +23,14 @@ class Assert::Runner
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(config1) }
+    subject{ unit_class.new(config1) }
 
     setup do
       config1.suite Assert::DefaultSuite.new(config1)
       config1.view  Assert::View.new(config1, StringIO.new(+"", "w+"))
     end
 
-    let(:config1) { Factory.modes_off_config }
+    let(:config1){ Factory.modes_off_config }
 
     should have_readers :config
     should have_imeths :runner, :run
@@ -49,7 +49,7 @@ class Assert::Runner
 
   class RunTests < InitTests
     desc "and run"
-    subject { runner_class1.new(config1) }
+    subject{ runner_class1.new(config1) }
 
     setup do
       @view_output = +""
@@ -64,9 +64,13 @@ class Assert::Runner
       @result_count = subject.run
     end
 
-    let(:runner_class1) { Class.new(unit_class) { include CallbackMixin } }
-    let(:ci1) { Factory.context_info(Factory.modes_off_context_class) }
-    let(:test1) { Factory.test("should pass", ci1){ assert(1==1) } }
+    let(:runner_class1) do
+      Class.new(unit_class){ include CallbackMixin }
+    end
+    let(:ci1){ Factory.context_info(Factory.modes_off_context_class) }
+    # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+    let(:test1){ Factory.test("should pass", ci1){ assert(1 == 1) } }
+    # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
 
     should "return the fail+error result count as an integer exit code" do
       assert_that(@result_count).equals(0)
@@ -75,7 +79,7 @@ class Assert::Runner
       error_count = Factory.integer
       Assert.stub(subject, :fail_result_count){ fail_count }
       Assert.stub(subject, :error_result_count){ error_count }
-      Assert.stub(test1, :run){ } # no-op
+      Assert.stub(test1, :run){} # no-op
       result_count = subject.run
 
       assert_that(result_count).equals(fail_count + error_count)
@@ -85,7 +89,8 @@ class Assert::Runner
       # itself
       assert_that(subject.on_start_called).is_true
       assert_that(subject.before_test_called).equals([test1])
-      assert_that(subject.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(subject.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(subject.after_test_called).equals([test1])
       assert_that(subject.on_finish_called).is_true
 
@@ -93,7 +98,8 @@ class Assert::Runner
       suite = config1.suite
       assert_that(suite.on_start_called).is_true
       assert_that(suite.before_test_called).equals([test1])
-      assert_that(suite.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(suite.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(suite.after_test_called).equals([test1])
       assert_that(suite.on_finish_called).is_true
 
@@ -101,7 +107,8 @@ class Assert::Runner
       view = config1.view
       assert_that(view.on_start_called).is_true
       assert_that(view.before_test_called).equals([test1])
-      assert_that(view.on_result_called.last).is_instance_of(Assert::Result::Pass)
+      assert_that(view.on_result_called.last)
+        .is_instance_of(Assert::Result::Pass)
       assert_that(view.after_test_called).equals([test1])
       assert_that(view.on_finish_called).is_true
     end
@@ -118,7 +125,9 @@ class Assert::Runner
     end
 
     should "run only a single test if a single test is configured" do
-      test = Factory.test("should pass", ci1){ assert(1==1) }
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      test = Factory.test("should pass", ci1){ assert(1 == 1) }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test)
       config1.single_test test.file_line.to_s
@@ -127,8 +136,11 @@ class Assert::Runner
       assert_that(runner.before_test_called).equals([test])
     end
 
-    should "not run any tests if a single test is configured but can't be found" do
-      test = Factory.test("should pass", ci1){ assert(1==1) }
+    should "not run any tests if a single test is configured but "\
+           "can't be found" do
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+      test = Factory.test("should pass", ci1){ assert(1 == 1) }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test)
       config1.single_test Factory.string
@@ -137,7 +149,8 @@ class Assert::Runner
       assert_that(runner.before_test_called).is_nil
     end
 
-    should "describe running only a single test if a single test is configured" do
+    should "describe running only a single test if a single test is "\
+           "configured" do
       config1.suite.clear_tests_to_run
       config1.suite.on_test(test1)
       config1.single_test test1.file_line.to_s