assert 2.19.1 → 2.19.6

data/test/unit/assertions/assert_respond_to_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_respond_to`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_respond_to(:abs, 1) # pass
         assert_respond_to(*args)   # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert respond to fail desc" }
-    let(:args1) { [:abs, "1", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert respond to fail desc" }
+    let(:args1){ [:abs, "1", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -41,17 +41,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_respond_to`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_respond_to(*args)     # fail
         assert_not_respond_to(:abs, "1") # pass
       end
-    }
+    end
 
-    let(:desc1) { "assert not respond to fail desc" }
-    let(:args1) { [:abs, 1, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not respond to fail desc" }
+    let(:args1){ [:abs, 1, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_same_tests.rb

@@ -10,20 +10,20 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_same`"
-    subject {
+    subject do
       args   = args1
       object = object1
       Factory.test do
         assert_same(object, object) # pass
         assert_same(*args)          # fail
       end
-    }
+    end
 
-    let(:class1) { Class.new }
-    let(:object1) { class1.new }
-    let(:desc1) { "assert same fail desc" }
-    let(:args1) { [object1, class1.new, desc1] }
-    let(:config1) { subject.config }
+    let(:class1){ Class.new }
+    let(:object1){ class1.new }
+    let(:desc1){ "assert same fail desc" }
+    let(:args1){ [object1, class1.new, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -46,7 +46,7 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_same`"
-    subject {
+    subject do
       args   = args1
       object = object1
       klass  = class1
@@ -54,13 +54,13 @@ module Assert::Assertions
         assert_not_same(*args)             # fail
         assert_not_same(object, klass.new) # pass
       end
-    }
+    end
 
-    let(:class1) { Class.new }
-    let(:object1) { class1.new }
-    let(:desc1) { "assert not same fail desc" }
-    let(:args1) { [object1, object1, desc1] }
-    let(:config1) { subject.config }
+    let(:class1){ Class.new }
+    let(:object1){ class1.new }
+    let(:desc1){ "assert not same fail desc" }
+    let(:args1){ [object1, object1, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -83,27 +83,27 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "with objects that should use diff when showing"
-    let(:config1) {
+    let(:config1) do
       Factory.modes_off_config.tap do |config|
         config.use_diff_proc(Assert::U.default_use_diff_proc)
         config.run_diff_proc(Assert::U.syscmd_diff_proc)
       end
-    }
+    end
 
-    let(:exp_obj1) { "I'm a\nstring" }
-    let(:act_obj1) { "I am a \nstring" }
-    let(:exp_obj_show1) { Assert::U.show_for_diff(exp_obj1, config1) }
-    let(:act_obj_show1) { Assert::U.show_for_diff(act_obj1, config1) }
+    let(:exp_obj1){ "I'm a\nstring" }
+    let(:act_obj1){ "I am a \nstring" }
+    let(:exp_obj_show1){ Assert::U.show_for_diff(exp_obj1, config1) }
+    let(:act_obj_show1){ Assert::U.show_for_diff(act_obj1, config1) }
   end
 
   class AssertSameDiffTests < DiffTests
     desc "`assert_same`"
-    subject {
+    subject do
       exp_obj, act_obj = exp_obj1, act_obj1
       Factory.test(config1) do
         assert_same(exp_obj, act_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)
@@ -120,12 +120,12 @@ module Assert::Assertions
 
   class AssertNotSameDiffTests < DiffTests
     desc "`assert_not_same`"
-    subject {
+    subject do
       act_obj = act_obj1
       Factory.test(config1) do
         assert_not_same(act_obj, act_obj)
       end
-    }
+    end
 
     should "include diff output in the fail messages" do
       subject.run(&test_run_callback)

data/test/unit/assertions/assert_true_false_tests.rb

@@ -10,17 +10,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_true`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_true(true)  # pass
         assert_true(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert true fail desc" }
-    let(:args1) { ["whatever", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert true fail desc" }
+    let(:args1){ ["whatever", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -29,7 +29,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be true."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "be true."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -38,17 +40,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_true`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_true(false) # pass
         assert_not_true(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not true fail desc" }
-    let(:args1) { [true, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not true fail desc" }
+    let(:args1){ [true, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -57,7 +59,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be true."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not be true."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -66,17 +70,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_false`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_false(false) # pass
         assert_false(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert false fail desc" }
-    let(:args1) { ["whatever", desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert false fail desc" }
+    let(:args1){ ["whatever", desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -85,7 +89,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to be false."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "be false."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end
@@ -94,17 +100,17 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "`assert_not_false`"
-    subject {
+    subject do
       args = args1
       Factory.test do
         assert_not_false(true)  # pass
         assert_not_false(*args) # fail
       end
-    }
+    end
 
-    let(:desc1) { "assert not false fail desc" }
-    let(:args1) { [false, desc1] }
-    let(:config1) { subject.config }
+    let(:desc1){ "assert not false fail desc" }
+    let(:args1){ [false, desc1] }
+    let(:config1){ subject.config }
 
     should "produce results as expected" do
       subject.run(&test_run_callback)
@@ -113,7 +119,9 @@ module Assert::Assertions
       assert_that(test_run_result_count(:pass)).equals(1)
       assert_that(test_run_result_count(:fail)).equals(1)
 
-      exp = "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to not be false."
+      exp =
+        "#{args1[1]}\nExpected #{Assert::U.show(args1[0], config1)} to "\
+        "not be false."
       assert_that(test_run_results(:fail).first.message).equals(exp)
     end
   end

data/test/unit/assertions_tests.rb

@@ -8,21 +8,26 @@ module Assert::Assertions
     include Assert::Test::TestHelpers
 
     desc "Assert::Context"
-    subject { context_class1.new(test1, test1.config, proc { |r| }) }
+    subject{ context_class1.new(test1, test1.config, proc{ |r| }) }
 
-    let(:context_class1) { Factory.modes_off_context_class }
-    let(:test1) { Factory.test }
+    let(:context_class1){ Factory.modes_off_context_class }
+    let(:test1){ Factory.test }
 
     should have_imeths :assert_block, :assert_not_block, :refute_block
     should have_imeths :assert_empty, :assert_not_empty, :refute_empty
     should have_imeths :assert_equal, :assert_not_equal, :refute_equal
-    should have_imeths :assert_file_exists, :assert_not_file_exists, :refute_file_exists
+    should have_imeths :assert_file_exists, :assert_not_file_exists
+    should have_imeths :refute_file_exists
     should have_imeths :assert_includes, :assert_not_includes
     should have_imeths :assert_included, :assert_not_included
     should have_imeths :refute_includes, :refute_included
-    should have_imeths :assert_instance_of, :assert_not_instance_of, :refute_instance_of
+    should have_imeths :assert_instance_of, :assert_not_instance_of
+    should have_imeths :refute_instance_of
+    should have_imeths :assert_is_a, :assert_is_not_a, :assert_not_a
+    should have_imeths :refute_is_a
     should have_imeths :assert_kind_of, :assert_not_kind_of, :refute_kind_of
-    should have_imeths :assert_match, :assert_not_match, :assert_no_match, :refute_match
+    should have_imeths :assert_match, :assert_not_match, :assert_no_match
+    should have_imeths :refute_match
     should have_imeths :assert_nil, :assert_not_nil, :refute_nil
     should have_imeths :assert_true, :assert_not_true, :refute_true
     should have_imeths :assert_false, :assert_not_false, :refute_false
@@ -41,14 +46,14 @@ module Assert::Assertions
       tests.each{ |test| test.run(&test_run_callback) }
     end
 
-    let(:tests) {
+    let(:tests) do
       context_info = Factory.context_info(context_class1)
       Assert::Assertions::IGNORED_ASSERTION_HELPERS.map do |helper|
         Factory.test("ignored assertion helper #{helper}", context_info) do
-          self.send(helper, "doesn't matter")
+          send(helper, "doesn't matter")
         end
       end
-    }
+    end
 
     should "have an ignored result for each helper in the constant" do
       exp = Assert::Assertions::IGNORED_ASSERTION_HELPERS.size

data/test/unit/config_helpers_tests.rb

@@ -8,9 +8,9 @@ require "assert/config"
 module Assert::ConfigHelpers
   class UnitTests < Assert::Context
     desc "Assert::ConfigHelpers"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) {
+    let(:unit_class) do
       Class.new do
         include Assert::ConfigHelpers
 
@@ -20,12 +20,12 @@ module Assert::ConfigHelpers
           @config ||= [Assert.config, Assert::Config.new].sample
         end
       end
-    }
+    end
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new }
+    subject{ unit_class.new }
 
     should have_imeths :runner, :suite, :view
     should have_imeths :runner_seed, :single_test?, :single_test_file_line
@@ -51,10 +51,10 @@ module Assert::ConfigHelpers
     end
 
     should "know if it is in single test mode" do
-      Assert.stub(subject.config, :single_test?) { true }
+      Assert.stub(subject.config, :single_test?){ true }
       assert_that(subject.single_test?).is_true
 
-      Assert.stub(subject.config, :single_test?) { false }
+      Assert.stub(subject.config, :single_test?){ false }
       assert_that(subject.single_test?).is_false
     end
 
@@ -119,7 +119,8 @@ module Assert::ConfigHelpers
 
       result_rate = Factory.float
       exp = format % result_rate
-      assert_that(subject.formatted_result_rate(result_rate, format)).equals(exp)
+      assert_that(subject.formatted_result_rate(result_rate, format))
+        .equals(exp)
       assert_that(subject.formatted_result_rate(result_rate)).equals(exp)
     end
 
@@ -137,17 +138,21 @@ module Assert::ConfigHelpers
     end
 
     should "know whether to show test profile info" do
-      assert_that(subject.show_test_profile_info?).equals(!!subject.config.profile)
+      assert_that(subject.show_test_profile_info?)
+        .equals(!!subject.config.profile)
     end
 
     should "know whether to show verbose info" do
-      assert_that(subject.show_test_verbose_info?).equals(!!subject.config.verbose)
+      assert_that(subject.show_test_verbose_info?)
+        .equals(!!subject.config.verbose)
     end
 
     should "know what result types occur in a suite's results" do
       result_types = [:pass, :fail, :ignore, :skip, :error]
       result_count = Factory.integer
-      Assert.stub(subject, "#{result_types.sample}_result_count"){ result_count }
+      Assert.stub(subject, "#{result_types.sample}_result_count") do
+        result_count
+      end
 
       exp = result_types.select do |type_sym|
         subject.send("#{type_sym}_result_count") > 0

data/test/unit/config_tests.rb

@@ -12,14 +12,14 @@ require "assert/runner"
 class Assert::Config
   class UnitTests < Assert::Context
     desc "Assert::Config"
-    subject { unit_class }
+    subject{ unit_class }
 
-    let(:unit_class) { Assert::Config }
+    let(:unit_class){ Assert::Config }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    subject { unit_class.new }
+    subject{ unit_class.new }
 
     should have_imeths :view, :suite, :runner
     should have_imeths :test_dir, :test_helper, :test_file_suffixes
@@ -29,6 +29,7 @@ class Assert::Config
     should have_imeths :verbose, :list, :debug
     should have_imeths :apply, :single_test?
     should have_imeths :single_test_file_line, :single_test_file_path
+    should have_imeths :env_runner_seed, :random_runner_seed
 
     should "default the view, suite, and runner" do
       assert_that(subject.view).is_kind_of(Assert::DefaultView)
@@ -63,19 +64,42 @@ class Assert::Config
       assert_that(subject.debug).is_false
     end
 
+    should "prefer a SEED env var, if present, for the runner seed value" do
+      orig_env_seed = ENV["SEED"]
+      new_env_seed = Factory.integer
+      ENV["SEED"] = new_env_seed.to_s
+
+      config = unit_class.new
+      assert_that(config.env_runner_seed).equals(new_env_seed.to_s)
+      assert_that(config.runner_seed).equals(config.env_runner_seed.to_i)
+
+      ENV["SEED"] = orig_env_seed
+    end
+
+    should "fallback to a random runner seed value if no SEED env var" do
+      orig_env_seed = ENV["SEED"]
+      ENV["SEED"] = nil
+
+      config = unit_class.new
+      assert_that(config.random_runner_seed).is_not_nil
+      assert_that(config.runner_seed).equals(config.random_runner_seed.to_i)
+
+      ENV["SEED"] = orig_env_seed
+    end
+
     should "apply settings given from a hash" do
       assert subject.halt_on_fail
-      subject.apply(:halt_on_fail => false)
+      subject.apply(halt_on_fail: false)
       assert_that(subject.halt_on_fail).is_false
 
       assert_that(Assert::Config.new.halt_on_fail).is_true
-      assert_that(Assert::Config.new(:halt_on_fail => false).halt_on_fail).is_false
+      assert_that(Assert::Config.new(halt_on_fail: false).halt_on_fail).is_false
     end
 
     should "know if it is in single test mode" do
       assert_that(subject.single_test?).is_false
 
-      subject.apply(:single_test => Factory.string)
+      subject.apply(single_test: Factory.string)
       assert_that(subject.single_test?).is_true
     end
 
@@ -84,7 +108,7 @@ class Assert::Config
       assert_that(subject.single_test_file_line).equals(exp)
 
       file_line_path = "#{Factory.path}_tests.rb:#{Factory.integer}"
-      subject.apply(:single_test => file_line_path)
+      subject.apply(single_test: file_line_path)
 
       exp = Assert::FileLine.parse(File.expand_path(file_line_path, Dir.pwd))
       assert_that(subject.single_test_file_line).equals(exp)
@@ -96,8 +120,9 @@ class Assert::Config
 
       path = "#{Factory.path}_tests.rb"
       file_line_path = "#{path}:#{Factory.integer}"
-      subject.apply(:single_test => file_line_path)
-      assert_that(subject.single_test_file_path).equals(File.expand_path(path, Dir.pwd))
+      subject.apply(single_test: file_line_path)
+      assert_that(subject.single_test_file_path)
+        .equals(File.expand_path(path, Dir.pwd))
     end
   end
 end