assert 2.18.4 → 2.19.4

data/test/unit/macro_tests.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "assert"
 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)
@@ -19,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
@@ -31,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
 
@@ -39,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
@@ -60,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
@@ -81,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
@@ -101,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
@@ -121,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,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)
@@ -29,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
@@ -122,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)
@@ -169,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
@@ -229,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)
@@ -240,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)
@@ -251,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
 
@@ -262,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)
@@ -271,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)
@@ -302,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)
@@ -317,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)
@@ -348,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)
@@ -375,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
@@ -391,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/runner"
 
@@ -10,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)
@@ -21,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+"))
+      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
@@ -47,10 +49,10 @@ class Assert::Runner
 
   class RunTests < InitTests
     desc "and run"
-    subject { runner_class1.new(config1) }
+    subject{ runner_class1.new(config1) }
 
     setup do
-      @view_output = ""
+      @view_output = +""
 
       suite_class = Class.new(Assert::DefaultSuite){ include CallbackMixin }
       view_class  = Class.new(Assert::View){ include CallbackMixin }
@@ -62,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)
@@ -73,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)
@@ -83,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
 
@@ -91,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
 
@@ -99,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
@@ -116,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
@@ -125,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
@@ -135,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

data/test/unit/suite_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/suite"
 
@@ -8,27 +10,22 @@ require "test/support/inherited_stuff"
 class Assert::Suite
   class UnitTests < Assert::Context
     desc "Assert::Suite"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Suite }
+    let(:unit_class){ Assert::Suite }
 
     should "include the config helpers" do
       assert_that(subject).includes(Assert::ConfigHelpers)
     end
-
-    should "know its test method regex" do
-      assert_that(subject::TEST_METHOD_REGEX).matches("test#{Factory.string}")
-      assert_that(subject::TEST_METHOD_REGEX).does_not_match("#{Factory.string}test")
-    end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new(config1) }
+    subject{ unit_class.new(config1) }
 
-    let(:config1) { Factory.modes_off_config }
+    let(:config1){ Factory.modes_off_config }
 
-    should have_readers :config, :test_methods, :setups, :teardowns
+    should have_readers :config, :setups, :teardowns
     should have_accessors :start_time, :end_time
     should have_imeths :suite, :setup, :startup, :teardown, :shutdown
     should have_imeths :tests_to_run?, :tests_to_run_count, :clear_tests_to_run
@@ -46,7 +43,6 @@ class Assert::Suite
     end
 
     should "default its attrs" do
-      assert_that(subject.test_methods).equals([])
       assert_that(subject.setups).equals([])
       assert_that(subject.teardowns).equals([])
 
@@ -78,8 +74,10 @@ class Assert::Suite
       Assert.stub(subject, :result_count){ count }
 
       assert_that(subject.run_time).equals(time)
-      assert_that(subject.test_rate).equals((subject.test_count / subject.run_time))
-      assert_that(subject.result_rate).equals((subject.result_count / subject.run_time))
+      assert_that(subject.test_rate)
+        .equals((subject.test_count / subject.run_time))
+      assert_that(subject.result_rate)
+        .equals((subject.result_count / subject.run_time))
     end
 
     should "add setup procs" do
@@ -110,17 +108,37 @@ class Assert::Suite
       tests1.each{ |test| subject.on_test(test) }
     end
 
-    let(:ci1) { proc{ Factory.context_info(Factory.modes_off_context_class) } }
-    let(:tests1) {
+    let(:ci1){ proc{ Factory.context_info(Factory.modes_off_context_class) } }
+    let(:tests1) do
+      # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
       [
-        Factory.test("should nothing", ci1.call){ },
-        Factory.test("should pass",    ci1.call){ assert(1==1); refute(1==0) },
-        Factory.test("should fail",    ci1.call){ ignore; assert(1==0); refute(1==1) },
-        Factory.test("should ignore",  ci1.call){ ignore },
-        Factory.test("should skip",    ci1.call){ skip; ignore; assert(1==1) },
-        Factory.test("should error",   ci1.call){ raise Exception; ignore; assert(1==1) }
+        Factory.test("should nothing", ci1.call) do
+        end,
+        Factory.test("should pass", ci1.call) do
+          assert(1 == 1)
+          refute(1 == 0)
+        end,
+        Factory.test("should fail", ci1.call) do
+          ignore
+          assert(1 == 0)
+          refute(1 == 1)
+        end,
+        Factory.test("should ignore", ci1.call) do
+          ignore
+        end,
+        Factory.test("should skip", ci1.call) do
+          skip
+          ignore
+          assert(1 == 1)
+        end,
+        Factory.test("should error", ci1.call) do
+          raise Exception
+          ignore # rubocop:disable Lint/UnreachableCode
+          assert(1 == 1)
+        end,
       ]
-    }
+      # rubocop:enable Lint/BinaryOperatorWithIdenticalOperands
+    end
 
     should "know its tests-to-run attrs" do
       assert_that(subject.tests_to_run_count).equals(tests1.size)
@@ -134,14 +152,14 @@ class Assert::Suite
 
     should "find a test to run given a file line" do
       test = tests1.sample
-      assert_that(subject.find_test_to_run(test.file_line)).is_the_same_as(test)
+      assert_that(subject.find_test_to_run(test.file_line)).is(test)
     end
 
     should "know its sorted tests to run" do
       sorted_tests = subject.sorted_tests_to_run{ 1 }
       assert_that(sorted_tests.size).equals(tests1.size)
       assert_that(sorted_tests.first).is_kind_of(Assert::Test)
-      assert_that(subject.sorted_tests_to_run{ 1 }.first).is_the_same_as(sorted_tests.first)
+      assert_that(subject.sorted_tests_to_run{ 1 }.first).is(sorted_tests.first)
     end
   end
 end