assert 2.19.1 → 2.19.6

data/test/unit/suite_tests.rb

@@ -10,9 +10,9 @@ 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)
@@ -21,9 +21,9 @@ class Assert::Suite
 
   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, :setups, :teardowns
     should have_accessors :start_time, :end_time
@@ -74,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
@@ -106,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)

data/test/unit/test_tests.rb

@@ -10,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
 
@@ -50,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
@@ -107,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
@@ -118,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
@@ -184,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)
 
@@ -192,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)
 
@@ -201,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
@@ -222,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)
 
@@ -230,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)
 
@@ -239,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
@@ -262,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)
 
@@ -270,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)
 
@@ -279,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
@@ -295,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)
@@ -332,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
@@ -349,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

@@ -9,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
@@ -47,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
@@ -94,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
@@ -112,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