assert 2.19.0 → 2.19.5

data/test/unit/test_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/test"
 
@@ -8,14 +10,16 @@ require "assert/result"
 class Assert::Test
   class UnitTests < Assert::Context
     desc "Assert::Test"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Test }
+    let(:unit_class){ Assert::Test }
 
-    let(:context_class1) { Factory.modes_off_context_class { desc "context class" } }
-    let(:context_info1)  { Factory.context_info(context_class1) }
-    let(:config1)        { Factory.modes_off_config }
-    let(:test_code1)     { proc { assert(true) } }
+    let(:context_class1) do
+      Factory.modes_off_context_class{ desc "context class" }
+    end
+    let(:context_info1){ Factory.context_info(context_class1) }
+    let(:config1){ Factory.modes_off_config }
+    let(:test_code1){ proc{ assert(true) } }
 
     should have_imeths :name_file_line_context_data, :for_block
 
@@ -48,24 +52,26 @@ class Assert::Test
 
   class InitWithDataTests < UnitTests
     desc "when init with data"
-    subject { unit_class.new(meta_data1.merge(run_data1)) }
+    subject{ unit_class.new(meta_data1.merge(run_data1)) }
 
-    let(:file_line1) { Assert::FileLine.new(Factory.string, Factory.integer.to_s) }
-    let(:meta_data1) {
+    let(:file_line1) do
+      Assert::FileLine.new(Factory.string, Factory.integer.to_s)
+    end
+    let(:meta_data1) do
       {
-        :file_line => file_line1.to_s,
-        :name      => Factory.string,
-        :output    => Factory.string,
-        :run_time  => Factory.float(1.0),
+        file_line: file_line1.to_s,
+        name: Factory.string,
+        output: Factory.string,
+        run_time: Factory.float(1.0),
       }
-    }
-    let(:run_data1) {
+    end
+    let(:run_data1) do
       {
-        :context_info => context_info1,
-        :config       => config1,
-        :code         => test_code1
+        context_info: context_info1,
+        config: config1,
+        code: test_code1,
       }
-    }
+    end
 
     should have_imeths :file_line, :file_name, :line_num
     should have_imeths :name, :output, :run_time
@@ -105,9 +111,12 @@ class Assert::Test
     end
 
     should "have a custom inspect that only shows limited attributes" do
-      attrs = [:name, :context_info].collect do |method|
-        "@#{method}=#{subject.send(method).inspect}"
-      end.join(" ")
+      attrs =
+        [:name, :context_info]
+          .map{ |method|
+            "@#{method}=#{subject.send(method).inspect}"
+          }
+          .join(" ")
       exp = "#<#{subject.class}:#{"0x0%x" % (subject.object_id << 1)} #{attrs}>"
       assert_that(subject.inspect).equals(exp)
     end
@@ -116,13 +125,13 @@ class Assert::Test
   class PassFailIgnoreHandlingTests < UnitTests
     include Assert::Test::TestHelpers
 
-    subject {
+    subject do
       Factory.test("pass fail ignore test", context_info1) do
         ignore("something")
         assert(true)
         assert(false)
       end
-    }
+    end
 
     setup do
       subject.context_class.setup do
@@ -182,7 +191,7 @@ class Assert::Test
     end
 
     should "capture fails in the context setup" do
-      test = Factory.test("setup halt-on-fail test", context_info1){ }
+      test = Factory.test("setup halt-on-fail test", context_info1){}
       test.context_class.setup{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -190,7 +199,7 @@ class Assert::Test
     end
 
     should "capture fails in the context teardown" do
-      test = Factory.test("teardown halt-on-fail test", context_info1){ }
+      test = Factory.test("teardown halt-on-fail test", context_info1){}
       test.context_class.teardown{ raise Assert::Result::TestFailure }
       test.run(&test_run_callback)
 
@@ -199,11 +208,13 @@ class Assert::Test
 
     private
 
-    def assert_failed(test)
+    def assert_failed(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few fail results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few fail results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Fail, "not a fail result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Fail, "not a fail result")
         end
       end
     end
@@ -220,7 +231,7 @@ class Assert::Test
     end
 
     should "capture skips in the context setup" do
-      test = Factory.test("setup skip test", context_info1){ }
+      test = Factory.test("setup skip test", context_info1){}
       test.context_class.setup{ skip }
       test.run(&test_run_callback)
 
@@ -228,7 +239,7 @@ class Assert::Test
     end
 
     should "capture skips in the context teardown" do
-      test = Factory.test("teardown skip test", context_info1){ }
+      test = Factory.test("teardown skip test", context_info1){}
       test.context_class.teardown{ skip }
       test.run(&test_run_callback)
 
@@ -237,11 +248,13 @@ class Assert::Test
 
     private
 
-    def assert_skipped(test)
+    def assert_skipped(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few skip results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few skip results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Skip, "not a skip result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Skip, "not a skip result")
         end
       end
     end
@@ -260,7 +273,7 @@ class Assert::Test
     end
 
     should "capture errors in the context setup" do
-      test = Factory.test("setup error test", context_info1){ }
+      test = Factory.test("setup error test", context_info1){}
       test.context_class.setup{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -268,7 +281,7 @@ class Assert::Test
     end
 
     should "capture errors in the context teardown" do
-      test = Factory.test("teardown error test", context_info1){ }
+      test = Factory.test("teardown error test", context_info1){}
       test.context_class.teardown{ raise "an error" }
       test.run(&test_run_callback)
 
@@ -277,11 +290,13 @@ class Assert::Test
 
     private
 
-    def assert_errored(test)
+    def assert_errored(_test)
       with_backtrace(caller) do
-        assert_that(test_run_result_count).equals(1, "too many/few error results")
+        assert_that(test_run_result_count)
+          .equals(1, "too many/few error results")
         test_run_results.each do |result|
-          assert_that(result).is_kind_of(Assert::Result::Error, "not an error result")
+          assert_that(result)
+            .is_kind_of(Assert::Result::Error, "not an error result")
         end
       end
     end
@@ -293,27 +308,27 @@ class Assert::Test
         raise SignalException, "USR1"
       end
 
-      assert_that { test.run }.raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context setup" do
-      test = Factory.test("setup signal test", context_info1){ }
+      test = Factory.test("setup signal test", context_info1){}
       test.context_class.setup{ raise SignalException, "INT" }
 
-      assert_that { test.run }.raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
 
     should "raises signal exceptions in the context teardown" do
-      test = Factory.test("teardown signal test", context_info1){ }
+      test = Factory.test("teardown signal test", context_info1){}
       test.context_class.teardown{ raise SignalException, "TERM" }
 
-      assert_that { test.run }.raises(SignalException)
+      assert_that{ test.run }.raises(SignalException)
     end
   end
 
   class ComparingTests < UnitTests
     desc "<=> another test"
-    subject { Factory.test("mmm") }
+    subject{ Factory.test("mmm") }
 
     should "return 1 with a test named 'aaa' (greater than it)" do
       assert_that(subject <=> Factory.test("aaa")).equals(1)
@@ -330,14 +345,14 @@ class Assert::Test
 
   class CaptureOutTests < UnitTests
     desc "when capturing std out"
-    subject {
+    subject do
       Factory.test("stdout", capture_config1) do
         puts "std out from the test"
         assert true
       end
-    }
+    end
 
-    let(:capture_config1) { Assert::Config.new(:capture_output => true) }
+    let(:capture_config1){ Assert::Config.new(capture_output: true) }
 
     should "capture any io from the test" do
       subject.run
@@ -347,12 +362,12 @@ class Assert::Test
 
   class FullCaptureOutTests < CaptureOutTests
     desc "across setup, teardown, and meth calls"
-    subject {
+    subject do
       Factory.test("fullstdouttest", capture_config1) do
         puts "std out from the test"
         assert a_method_an_assert_calls
       end
-    }
+    end
 
     setup do
       subject.context_class.setup{ puts "std out from the setup" }

data/test/unit/utils_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/utils"
 
@@ -7,37 +9,40 @@ require "assert/config"
 module Assert::Utils
   class UnitTests < Assert::Context
     desc "Assert::Utils"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Utils }
+    let(:unit_class){ Assert::Utils }
 
-    let(:objs1) { [1, "hi there", Hash.new, [:a, :b]] }
+    let(:objs1){ [1, "hi there", {}, [:a, :b]] }
 
     should have_imeths :show, :show_for_diff
     should have_imeths :tempfile
-    should have_imeths :stdlib_pp_proc, :default_use_diff_proc, :syscmd_diff_proc
+    should have_imeths :stdlib_pp_proc, :default_use_diff_proc
+    should have_imeths :syscmd_diff_proc
     should have_imeths :git_changed_proc
   end
 
   class ShowTests < UnitTests
     desc "`show`"
 
-    let(:pp_config1) {
+    let(:pp_config1) do
       Assert::Config.new({
-        :pp_objects => true,
-        :pp_proc => Proc.new{ |input| "herp derp" }
+        pp_objects: true,
+        pp_proc: Proc.new{ |_input| "herp derp" },
       })
-    }
+    end
 
     should "use `inspect` to show objs when `pp_objects` setting is false" do
       objs1.each do |obj|
-        assert_that(subject.show(obj, Factory.modes_off_config)).equals(obj.inspect)
+        assert_that(subject.show(obj, Factory.modes_off_config))
+          .equals(obj.inspect)
       end
     end
 
     should "use `pp_proc` to show objs when `pp_objects` setting is true" do
       objs1.each do |obj|
-        assert_that(subject.show(obj, pp_config1)).equals(pp_config1.pp_proc.call(obj))
+        assert_that(subject.show(obj, pp_config1))
+          .equals(pp_config1.pp_proc.call(obj))
       end
     end
   end
@@ -45,24 +50,27 @@ module Assert::Utils
   class ShowForDiffTests < ShowTests
     desc "`show_for_diff`"
 
-    let(:w_newlines1) { { :string => "herp derp, derp herp\nherpderpedia" } }
-    let(:w_obj_id1) { Class.new.new }
+    let(:w_newlines1){ { string: "herp derp, derp herp\nherpderpedia" } }
+    let(:w_obj_id1){ Class.new.new }
 
     should "call show, escaping newlines" do
       exp_out = "{:string=>\"herp derp, derp herp\nherpderpedia\"}"
-      assert_that(subject.show_for_diff(w_newlines1, Factory.modes_off_config)).equals(exp_out)
+      assert_that(subject.show_for_diff(w_newlines1, Factory.modes_off_config))
+        .equals(exp_out)
     end
 
     should "make any obj ids generic" do
       exp_out = "#<#<Class:0xXXXXXX>:0xXXXXXX>"
-      assert_that(subject.show_for_diff(w_obj_id1, Factory.modes_off_config)).equals(exp_out)
+      assert_that(subject.show_for_diff(w_obj_id1, Factory.modes_off_config))
+        .equals(exp_out)
     end
   end
 
   class TempfileTests < UnitTests
     desc "`tempfile`"
 
-    should "require tempfile, open a tempfile, write the given content, and yield it" do
+    should "require tempfile, open a tempfile, write the given content, "\
+           "and yield it" do
       subject.tempfile("a-name", "some-content") do |tmpfile|
         assert_that((require "tempfile")).equals(false)
         assert tmpfile
@@ -78,12 +86,12 @@ module Assert::Utils
     desc "`stdlib_pp_proc`"
 
     should "build a pp proc that uses stdlib `PP.pp` to pretty print objects" do
-      exp_obj_pps = objs1.map{ |o| PP.pp(o, "", 79).strip }
+      exp_obj_pps = objs1.map{ |o| PP.pp(o, +"", 79).strip }
       act_obj_pps = objs1.map{ |o| subject.stdlib_pp_proc.call(o) }
       assert_that(act_obj_pps).equals(exp_obj_pps)
 
       cust_width = 1
-      exp_obj_pps = objs1.map{ |o| PP.pp(o, "", cust_width).strip }
+      exp_obj_pps = objs1.map{ |o| PP.pp(o, +"", cust_width).strip }
       act_obj_pps = objs1.map{ |o| subject.stdlib_pp_proc(cust_width).call(o) }
       assert_that(act_obj_pps).equals(exp_obj_pps)
     end
@@ -92,8 +100,10 @@ module Assert::Utils
   class DefaultUseDiffProcTests < UnitTests
     desc "`default_use_diff_proc`"
 
-    let(:longer1)   { "i am a really long string output; use diff when working with me" }
-    let(:newlines1) { "i have\n newlines" }
+    let(:longer1) do
+      "i am a really long string output; use diff when working with me"
+    end
+    let(:newlines1){ "i have\n newlines" }
 
     should "be true if either output has newlines or is bigger than 29 chars" do
       proc = subject.default_use_diff_proc
@@ -110,28 +120,33 @@ module Assert::Utils
   class SyscmdDiffProc < UnitTests
     desc "`syscmd_diff_proc`"
 
-    let(:diff_a_file1) { File.join(ROOT_PATH, "test/support/diff_a.txt") }
-    let(:diff_b_file1) { File.join(ROOT_PATH, "test/support/diff_b.txt") }
-    let(:diff_a1)      { File.read(diff_a_file1) }
-    let(:diff_b1)      { File.read(diff_b_file1) }
-
-    should "use the diff syscmd to output the diff between the exp/act show output" do
-      exp_diff_out = `diff --unified=-1 #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
-        out.sub!(/^\-\-\- .+/, "--- expected")
-        out.sub!(/^\+\+\+ .+/, "+++ actual")
-      end
-
-      assert_that(subject.syscmd_diff_proc.call(diff_a1, diff_b1)).equals(exp_diff_out)
+    let(:diff_a_file1){ File.join(ROOT_PATH, "test/support/diff_a.txt") }
+    let(:diff_b_file1){ File.join(ROOT_PATH, "test/support/diff_b.txt") }
+    let(:diff_a1){ File.read(diff_a_file1) }
+    let(:diff_b1){ File.read(diff_b_file1) }
+
+    should "use the diff syscmd to output the diff between the exp/act "\
+           "show output" do
+      exp_diff_out =
+        `diff --unified=-1 #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
+          out.sub!(/^\-\-\- .+/, "--- expected")
+          out.sub!(/^\+\+\+ .+/, "+++ actual")
+        end
+
+      assert_that(subject.syscmd_diff_proc.call(diff_a1, diff_b1))
+        .equals(exp_diff_out)
     end
 
     should "allow you to specify a custom syscmd" do
       cust_syscmd = "diff"
-      exp_diff_out = `#{cust_syscmd} #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
-        out.sub!(/^\-\-\- .+/, "--- expected")
-        out.sub!(/^\+\+\+ .+/, "+++ actual")
-      end
-
-      assert_that(subject.syscmd_diff_proc(cust_syscmd).call(diff_a1, diff_b1)).equals(exp_diff_out)
+      exp_diff_out =
+        `#{cust_syscmd} #{diff_a_file1} #{diff_b_file1}`.strip.tap do |out|
+          out.sub!(/^\-\-\- .+/, "--- expected")
+          out.sub!(/^\+\+\+ .+/, "+++ actual")
+        end
+
+      assert_that(subject.syscmd_diff_proc(cust_syscmd).call(diff_a1, diff_b1))
+        .equals(exp_diff_out)
     end
   end
 end

data/test/unit/view_helpers_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/view_helpers"
 
@@ -10,9 +12,9 @@ require "assert/view"
 module Assert::ViewHelpers
   class UnitTests < Assert::Context
     desc "Assert::ViewHelpers"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) {
+    let(:unit_class) do
       test_opt_val = test_opt_val1
       Class.new do
         include Assert::ViewHelpers
@@ -25,9 +27,9 @@ module Assert::ViewHelpers
           @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
-    }
+    end
 
-    let(:test_opt_val1) { Factory.string }
+    let(:test_opt_val1){ Factory.string }
 
     should have_imeths :option
 
@@ -51,7 +53,7 @@ module Assert::ViewHelpers
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new }
+    subject{ unit_class.new }
 
     should have_imeths :captured_output, :re_run_test_cmd
     should have_imeths :tests_to_run_count_statement, :result_count_statement
@@ -75,7 +77,9 @@ module Assert::ViewHelpers
     end
 
     should "know its tests-to-run count and result count statements" do
-      exp = "#{subject.tests_to_run_count} test#{"s" if subject.tests_to_run_count != 1}"
+      exp =
+        "#{subject.tests_to_run_count} "\
+        "test#{"s" if subject.tests_to_run_count != 1}"
       assert_that(subject.tests_to_run_count_statement).equals(exp)
 
       exp = "#{subject.result_count} result#{"s" if subject.result_count != 1}"
@@ -89,7 +93,7 @@ module Assert::ViewHelpers
       items = 2.times.map{ Factory.string }
       assert_that(subject.to_sentence(items)).equals(items.join(" and "))
 
-      items = (Factory.integer(3)+2).times.map{ Factory.string }
+      items = (Factory.integer(3) + 2).times.map{ Factory.string }
       exp = [items[0..-2].join(", "), items.last].join(", and ")
       assert_that(subject.to_sentence(items)).equals(exp)
     end
@@ -101,7 +105,7 @@ module Assert::ViewHelpers
       Assert.stub(subject, :result_count){ 1 }
       assert_that(subject.all_pass_result_summary_msg).equals("pass")
 
-      Assert.stub(subject, :result_count){ Factory.integer(10)+1 }
+      Assert.stub(subject, :result_count){ Factory.integer(10) + 1 }
       assert_that(subject.all_pass_result_summary_msg).equals("all pass")
     end
 
@@ -113,7 +117,7 @@ module Assert::ViewHelpers
 
       Assert.stub(subject, :all_pass?){ false }
       res_type = [:pass, :ignore, :fail, :skip, :error].sample
-      exp = "#{subject.send("#{res_type}_result_count")} #{res_type.to_s}"
+      exp = "#{subject.send("#{res_type}_result_count")} #{res_type}"
       assert_that(subject.result_summary_msg(res_type)).equals(exp)
     end
 
@@ -137,7 +141,7 @@ module Assert::ViewHelpers
 
   class AnsiTests < UnitTests
     desc "Ansi"
-    subject { Ansi }
+    subject{ Ansi }
 
     should have_imeths :code_for
 
@@ -160,10 +164,12 @@ module Assert::ViewHelpers
 
   class AnsiInitTests < UnitTests
     desc "when mixed in on a view"
-    subject { view1 }
+    subject{ view1 }
 
-    let(:view_class1) { Class.new(Assert::View){ include Ansi } }
-    let(:view1) { view_class1.new(Factory.modes_off_config, StringIO.new("", "w+")) }
+    let(:view_class1){ Class.new(Assert::View){ include Ansi } }
+    let(:view1) do
+      view_class1.new(Factory.modes_off_config, StringIO.new(+"", "w+"))
+    end
 
     should have_imeths :ansi_styled_msg
 
@@ -188,7 +194,10 @@ module Assert::ViewHelpers
       Assert.stub(subject, "#{result_type}_styles"){ [] }
       assert_that(subject.ansi_styled_msg(msg, result_type)).equals(msg)
 
-      styles = Factory.integer(3).times.map{ Assert::ViewHelpers::Ansi::CODES.keys.sample }
+      styles =
+        Factory.integer(3).times.map do
+          Assert::ViewHelpers::Ansi::CODES.keys.sample
+        end
       Assert.stub(subject, "#{result_type}_styles"){ styles }
       exp_code = Assert::ViewHelpers::Ansi.code_for(*styles)
       exp = exp_code + msg + Assert::ViewHelpers::Ansi.code_for(:reset)