assert 2.18.4 → 2.19.4

data/test/unit/test_tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "assert"
 require "assert/test"
 
@@ -8,16 +10,18 @@ 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, :for_method
+    should have_imeths :name_file_line_context_data, :for_block
 
     should "know how to build the name and file line given context" do
       test_name = Factory.string
@@ -44,50 +48,30 @@ class Assert::Test
       assert_that(test.config).equals(config1)
       assert_that(test.code).equals(test_code1)
     end
-
-    should "build tests for a method" do
-      meth = "a_test_method"
-      test = subject.for_method(meth, context_info1, config1)
-
-      exp = Assert::FileLine.parse(context_info1.called_from)
-      assert_that(test.file_line).equals(exp)
-
-      exp = context_info1.test_name(meth)
-      assert_that(test.name).equals(exp)
-
-      assert_that(test.context_info).equals(context_info1)
-      assert_that(test.config).equals(config1)
-
-      assert_that(test.code).is_kind_of(Proc)
-      self.instance_eval(&test.code)
-      assert_that(@a_test_method_called).is_true
-    end
-
-    def a_test_method
-      @a_test_method_called = true
-    end
   end
 
   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
@@ -127,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
@@ -138,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
@@ -204,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)
 
@@ -212,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)
 
@@ -221,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
@@ -242,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)
 
@@ -250,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)
 
@@ -259,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
@@ -282,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)
 
@@ -290,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)
 
@@ -299,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
@@ -315,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)
@@ -352,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
@@ -369,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