minitest-bisect 1.4.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cff92ce857a2c5a2a5ec16125c68b77513490096eeb225d88c9a386e01c7970e
-  data.tar.gz: e9683eb9d3f1960aa90f2558aa860eb372cfd1f12053536e651917e7a02fb256
+  metadata.gz: 0adf4dd9767c961c0030a23e4e200245d74505bb0c5bd79dc0ff4201adeadc63
+  data.tar.gz: 501678cbbf5567c3408f1e44721dcbb11bc917b8e2d77c7ca063652e5ffc133f
 SHA512:
-  metadata.gz: 5b4867ee6ac8d70e7fc85d7a1e5982db15d161f8f5deac85d1def14bf0a8ffdfad921924a6d7fe5137ca0445a65908c4d00668456bcfcad6a965cd13e1437459
-  data.tar.gz: a5548ed9cd15fb5174e2e8f8a51998818431603410aa95015357651b6394e9333e71cb41a278ae4f854c992bec7aa3a218a91227b7d6883d6d68d3e78e71615b
+  metadata.gz: 3c9f20afc3dcd8cb7e782caaa456e8f9dded619624226c9a7123290cc8cd47abe1ec32afdc1acd61dba41b1d1d1797389296e45f7abc234c27eca3206a8f5473
+  data.tar.gz: 3db4728af1051d31167814e277af68ee39fc0451a3c8df5c45f417a64b7d5fac8e72a9f2b5a590fa816566f1397f91429c1f16d608cba811d361faad246e7f6b

data/History.rdoc

@@ -1,3 +1,26 @@
+=== 1.6.0 / 2022-05-23
+
+* 1 minor enhancement:
+
+  * Removed #bisect_files and mode accessor. Just deal with methods only for now.
+
+=== 1.5.1 / 2019-09-22
+
+* 1 bug fix:
+
+  * Fixed a bug where having only options would prevent default "test" directory arg.
+
+=== 1.5.0 / 2019-06-06
+
+* 2 minor enhancements:
+
+  * Print out the culprit methods once done.
+  * Default to using -Itest:lib like minitest-sprint.
+
+* 1 bug fix:
+
+  * Remove the server arguments from the final repro output.
+
 === 1.4.1 / 2019-05-26
 
 * 2 bug fixes:

data/README.rdoc

@@ -30,13 +30,37 @@ Let's say you have a bunch of test files and they fail sometimes, but
 not consistently. You get a run that fails, so you record the
 randomization seed that minitest displays at the top of every run.
 
+=== Normally, it passes:
+
+  % minitest example
+  Run options: --seed 42
+
+  # Running:
+
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ..............................................................................
+  ....................
+
+  Finished in 200.341744s, 3.6371 runs/s, 3.4230 assertions/s.
+
+  800 runs, 798 assertions, 0 failures, 0 errors, 0 skips
+
 === Original Failure:
 
-Here's an example run that fails randomly:
+But someone sees the failure either locally or on the CI. They record
+the output and get the randomization seed that causes the test
+ordering bug:
 
-  $ rake
-  ruby -I.:lib -e 'require "example/test_bad1.rb";require "example/test_bad2.rb";require "example/test_bad3.rb";require "example/test_bad4.rb";require "example/test_bad5.rb";require "example/test_bad6.rb";require "example/test_bad7.rb";require "example/test_bad8.rb"'
-  Run options: --seed 3911
+  $ minitest example --seed 314
+  Run options: --seed 314
 
   # Running:
 
@@ -73,58 +97,50 @@ same order and reproduce every time.
 minitest_bisect will first minimize the number of files, then it will
 turn around and minimize the number of methods.
 
-  $ minitest_bisect --seed 3911 example/test*.rb
-  reproducing...
-  reproduced
-  # of culprit files: 4
-  # of culprit files: 2
-  # of culprit files: 2
-  # of culprit files: 2
-  # of culprit files: 2
+  % minitest_bisect example --seed 314
+  reproducing... in 203.83 sec
+  verifying... in 0.37 sec
+  # of culprit methods: 64 in 16.65 sec
+  # of culprit methods: 32 in 8.53 sec
+  # of culprit methods: 32 in 8.52 sec
+  # of culprit methods: 16 in 4.46 sec
+  # of culprit methods: 16 in 4.44 sec
+  # of culprit methods: 8 in 2.41 sec
+  # of culprit methods: 4 in 1.40 sec
+  # of culprit methods: 2 in 0.89 sec
+  # of culprit methods: 2 in 0.89 sec
+  # of culprit methods: 1 in 0.62 sec
+  # of culprit methods: 1 in 0.63 sec
 
-  Minimal files found in 5 steps:
+  Minimal methods found in 11 steps:
 
-  ruby -Ilib -e 'require "./example/test_bad1.rb" ; require "./example/test_bad4.rb"' -- --seed 3911 -s 48222
+  Culprit methods: ["TestBad1#test_bad1_1"]
 
-  reproducing...
-  reproduced
-  # of culprit methods: 64
-  # of culprit methods: 64
-  # of culprit methods: 32
-  # of culprit methods: 16
-  # of culprit methods: 8
-  # of culprit methods: 8
-  # of culprit methods: 4
-  # of culprit methods: 2
-  # of culprit methods: 2
-  # of culprit methods: 1
-
-  Minimal methods found in 10 steps:
-
-  ruby -Ilib -e 'require "./example/test_bad1.rb" ; require "./example/test_bad4.rb"' -- --seed 3911 -s 48222 -n '/^(?:TestBad1\#test_bad1_1|TestBad4\#test_bad4_4)$/'
+  ruby -Itest:lib -e 'require "./example/test_bad1.rb" ; require "./example/test_bad2.rb" ; require "./example/test_bad3.rb" ; require "./example/test_bad4.rb" ; require "./example/test_bad5.rb" ; require "./example/test_bad6.rb" ; require "./example/test_bad7.rb" ; require "./example/test_bad8.rb"' -- --seed 314 -n "/^(?:TestBad1#(?:test_bad1_1)|TestBad4#(?:test_bad4_4))$/"
 
   Final reproduction:
 
-  Run options: --seed 3911 -s 48222 -n "/^(?:TestBad1\\#test_bad1_1|TestBad4\\#test_bad4_4)$/"
+  Run options: --seed 314 -n "/^(?:TestBad1#(?:test_bad1_1)|TestBad4#(?:test_bad4_4))$/"
 
   # Running:
 
   .F
 
-  Finished in 0.505776s, 3.9543 runs/s, 1.9772 assertions/s.
+  Finished in 0.512999s, 3.8986 runs/s, 1.9493 assertions/s.
 
     1) Failure:
   TestBad4#test_bad4_4 [/Users/ryan/Work/p4/zss/src/minitest-bisect/dev/example/helper.rb:16]:
   muahahaha order dependency bug!
 
-  2 runs, 1 assertions, 1 failures, 0 errors, 0 skips
-
 Voila! This reduced it from 800 tests across 8 files down to 2 tests
-across 2 files. Note how we went from a 200 second test run to a 0.5
-second test run. Debugging that will be much easier.
+across 2 files. Note how we went from a ~200 second test run to a ~0.5
+second test run. Debugging that will be 400x faster and that much
+easier.
+
+=== What Now?
 
-It is now up to you to look at the source of both of those tests to
-determine what side-effects (or lack thereof) are causing your test
+Now, it is now up to you to look at the source of both of those tests
+to determine what side-effects (or lack thereof) are causing your test
 failure when run in this specific order.
 
 This happens in a single run. Depending on how many files / tests you

data/Rakefile

@@ -8,6 +8,7 @@ Hoe.plugin :seattlerb
 Hoe.plugin :rdoc
 
 Hoe.add_include_dirs "../../minitest-server/dev/lib"
+Hoe.add_include_dirs "../../path_expander/dev/lib"
 
 Hoe.spec "minitest-bisect" do
   developer "Ryan Davis", "ryand-ruby@zenspider.com"
@@ -15,7 +16,7 @@ Hoe.spec "minitest-bisect" do
 
   dependency "rake", "> 0", :development
   dependency "minitest-server", "~> 1.0"
-  dependency "path_expander", "~> 1.0"
+  dependency "path_expander", "~> 1.1"
 end
 
 require "rake/testtask"

data/example-many/helper.rb

@@ -14,7 +14,7 @@ def create_test suffix, n_methods, bad_methods = {}
         case bad_methods[n]
         when true then
           $hosed += 1
-        when Fixnum then
+        when Integer then
           flunk "muahahaha order dependency bug!" if $hosed >= bad_methods[n]
         else
           assert true

data/lib/minitest/bisect.rb

@@ -5,7 +5,7 @@ require "rbconfig"
 require "path_expander"
 
 class Minitest::Bisect
-  VERSION = "1.4.1"
+  VERSION = "1.6.0"
 
   class PathExpander < ::PathExpander
     TEST_GLOB = "**/{test_*,*_test,spec_*,*_spec}.rb" # :nodoc:
@@ -13,8 +13,8 @@ class Minitest::Bisect
     attr_accessor :rb_flags
 
     def initialize args = ARGV # :nodoc:
-      super args, TEST_GLOB
-      self.rb_flags = []
+      super args, TEST_GLOB, "test"
+      self.rb_flags = %w[-Itest:lib]
     end
 
     ##
@@ -51,7 +51,7 @@ class Minitest::Bisect
               RbConfig::CONFIG['ruby_install_name'] +
                 RbConfig::CONFIG['EXEEXT']).sub(/.*\s.*/m, '"\&"')
 
-  attr_accessor :tainted, :failures, :culprits, :mode, :seen_bad
+  attr_accessor :tainted, :failures, :culprits, :seen_bad
   alias :tainted? :tainted
 
   def self.run files
@@ -78,18 +78,14 @@ class Minitest::Bisect
 
     cmd = nil
 
-    if :until_I_have_negative_filtering_in_minitest != 0 then
-      mt_flags = args.dup
-      expander = Minitest::Bisect::PathExpander.new mt_flags
+    mt_flags = args.dup
+    expander = Minitest::Bisect::PathExpander.new mt_flags
 
-      files = expander.process
-      rb_flags = expander.rb_flags
-      mt_flags += ["--server", $$]
+    files = expander.process
+    rb_flags = expander.rb_flags
+    mt_flags += ["--server", $$]
 
-      cmd = bisect_methods build_files_cmd(files, rb_flags, mt_flags)
-    else
-      cmd = bisect_methods bisect_files args
-    end
+    cmd = bisect_methods build_files_cmd(files, rb_flags, mt_flags)
 
     puts "Final reproduction:"
     puts
@@ -99,37 +95,7 @@ class Minitest::Bisect
     Minitest::Server.stop
   end
 
-  def bisect_files files
-    self.mode = :files
-
-    files, flags = files.partition { |arg| File.file? arg }
-    rb_flags, mt_flags = flags.partition { |arg| arg =~ /^-I/ }
-    mt_flags += ["--server", $$]
-
-    puts "reproducing..."
-    system "#{build_files_cmd files, rb_flags, mt_flags} #{SHH}"
-    abort "Reproduction run passed? Aborting. Try running with MTB_VERBOSE=2 to verify." unless tainted?
-    puts "reproduced"
-
-    found, count = files.find_minimal_combination_and_count do |test|
-      puts "# of culprit files: #{test.size}"
-
-      system "#{build_files_cmd test, rb_flags, mt_flags} #{SHH}"
-
-      self.tainted?
-    end
-
-    puts
-    puts "Minimal files found in #{count} steps:"
-    puts
-    cmd = build_files_cmd found, rb_flags, mt_flags
-    puts cmd
-    cmd
-  end
-
   def bisect_methods cmd
-    self.mode = :methods
-
     time_it "reproducing...", build_methods_cmd(cmd)
 
     unless tainted? then
@@ -162,8 +128,10 @@ class Minitest::Bisect
     puts
     puts "Minimal methods found in #{count} steps:"
     puts
+    puts "Culprit methods: %p" % [found]
+    puts
     cmd = build_methods_cmd cmd, found, bad
-    puts cmd
+    puts cmd.sub(/--server \d+/, "")
     puts
     cmd
   end
@@ -243,12 +211,10 @@ class Minitest::Bisect
   def minitest_result file, klass, method, fails, assertions, time
     fails.reject! { |fail| Minitest::Skip === fail }
 
-    if mode == :methods then
-      if fails.empty? then
-        culprits << "#{klass}##{method}" unless seen_bad # UGH
-      else
-        self.seen_bad = true
-      end
+    if fails.empty? then
+      culprits << "#{klass}##{method}" unless seen_bad # UGH
+    else
+      self.seen_bad = true
     end
 
     return if fails.empty?

data/test/minitest/test_bisect.rb

@@ -8,6 +8,7 @@ class TestMinitest::TestBisect < Minitest::Test
 
   def setup
     self.bisect = Minitest::Bisect.new
+    bisect.reset
   end
 
   def test_class_run
@@ -124,9 +125,6 @@ class TestMinitest::TestBisect < Minitest::Test
   end
 
   def test_minitest_result
-    bisect.mode = :methods
-    bisect.reset
-
     bisect.minitest_result "file.rb", "TestClass", "test_method", [], 1, 1
 
     assert_equal false, bisect.tainted
@@ -135,9 +133,6 @@ class TestMinitest::TestBisect < Minitest::Test
   end
 
   def test_minitest_result_skip
-    bisect.mode = :methods
-    bisect.reset
-
     fail = Minitest::Skip.new("woot")
 
     bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
@@ -148,9 +143,6 @@ class TestMinitest::TestBisect < Minitest::Test
   end
 
   def test_minitest_result_fail
-    bisect.mode = :methods
-    bisect.reset
-
     fail = Minitest::Assertion.new "msg"
 
     bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
@@ -163,9 +155,6 @@ class TestMinitest::TestBisect < Minitest::Test
   end
 
   def test_minitest_result_error
-    bisect.mode = :methods
-    bisect.reset
-
     fail = Minitest::UnexpectedError.new RuntimeError.new("woot")
 
     bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
@@ -220,7 +209,7 @@ class TestMinitest::TestBisect::TestPathExpander < Minitest::Test
     expander = mtbpe.new args
 
     assert_kind_of PathExpander, expander
-    assert_equal [], expander.rb_flags
+    assert_equal %w[-Itest:lib], expander.rb_flags
     assert_same mtbpe::TEST_GLOB, expander.glob
   end
 
@@ -230,7 +219,7 @@ class TestMinitest::TestBisect::TestPathExpander < Minitest::Test
     expander = Minitest::Bisect::PathExpander.new args
 
     exp_files = %w[1 2 3 4 5 6]
-    exp_flags = %w[-Iblah -d -w]
+    exp_flags = %w[-Itest:lib -Iblah -d -w]
 
     files = expander.process_flags(args)
 

data/test/minitest/test_find_minimal_combination.rb

@@ -10,93 +10,99 @@ describe Array, :find_minimal_combination do
     lambda { |sample| bad & sample == bad }
   end
 
+  def record_and_check(tests, *bad)
+    lambda { |test| tests << test.join; bad & test == bad }
+  end
+
+  def parse_trials s
+    s.lines.map { |s| s.chomp.sub(/#.*/, '').delete " " }.reject(&:empty?)
+  end
+
   def assert_steps input, bad, exp
     tests = []
 
-    found = input.find_minimal_combination do |test|
-      tests << test
-      bad & test == bad
-    end
+    found = input.find_minimal_combination(&record_and_check(tests, *bad))
 
     assert_equal bad, found, "algorithm is bad"
 
-    assert_equal exp, tests
+    assert_equal parse_trials(exp), tests
   end
 
-  def test_ordering_best_case
-    a   = (0..15).to_a
-    bad = [0, 1]
-    exp = [[0, 1, 2, 3, 4, 5, 6, 7],
-           [0, 1, 2, 3],
-           [0, 1],
-           [0],
-           [1],
-           [0, 1]]
-
-    assert_steps a, bad, exp
+  HEX = "0123456789ABCDEF".chars.to_a
+
+  # lvl      collection
+  #
+  #  0 |         A
+  #  1 |     B       C
+  #  2 |   D   E   F   G
+  #  3 |  H I J K L M N O
+  #    |
+  #  4 |  0123456789ABCDEF
+
+  def test_ordering_best_case_1
+    ary = HEX
+    bad = %w[0]
+    exp = <<~EOT
+      #123456789ABCDEF
+      01234567         # HIT! -- level 1 = B, C
+      0123             # HIT! -- level 2 = D, E
+      01               # HIT! -- level 3 = H, I
+      0                # HIT!
+    EOT
+
+    assert_steps ary, bad, exp
   end
 
-  def test_ordering
-    a     = (0..15).to_a
-    bad   = [0, 15]
-
-    # lvl              collection
-    #
-    #  0 |                 A
-    #  1 |         B               C
-    #  2 |     D       E       F       G
-    #  3 |   H   I   J   K   L   M   N   O
-    #  4 |  0 1 2 3 4 5 6 7 8 9 A B C D E F
-    #
-    #  0    +++++++++++++++++++++++++++++++
-    #  1    ---------------
-    #  1                    ---------------
-    #  2    -------         -------
-    #  2    +++++++                 +++++++
-    #  3    xxxxxxx
-    #  3                            xxxxxxx
-    #  3    ---                     ---
-    #  3    +++                         +++
-    #  4    xxx
-    #  4                                xxx
-    #  4    -                           -
-    #  4    +                             +
-    #
-    #  - = miss
-    #  + = hit
-    #  x = unwanted test
-
-    exp = [
-           # level 1 = B, C
-           [0, 1, 2, 3, 4, 5, 6, 7],
-           [8, 9, 10, 11, 12, 13, 14, 15],
-
-           # level 2 = DF, DG, EF, EG
-           [0, 1, 2, 3, 8, 9, 10, 11],
-           [0, 1, 2, 3, 12, 13, 14, 15],
-
-           # level 3
-           # [0, 1, 2, 3],     # I think this is bad, we've tested B
-           # [12, 13, 14, 15], # again, bad, we've tested C
-           [0, 1, 12, 13],
-           [0, 1, 14, 15],
-
-           # level 4
-           # [0, 1],
-           # [14, 15],
-           [0, 14],
-           [0, 15],
-          ]
-
-    assert_steps a, bad, exp
+  def test_ordering_best_case_2
+    ary = HEX
+    bad = %w[0 1]
+    exp = <<~EOT
+      01234567         # HIT! -- level 1 = B, C
+      0123             # HIT! -- level 2 = D, E
+      01               # HIT! -- level 3 = H, I
+      0                # miss -- level 4 = 0, 1, n_combos = 1
+       1               # miss
+      01               # HIT! -- level 3 = H,    n_combos = 2
+    EOT
+
+    assert_steps ary, bad, exp
   end
 
-  make_my_diffs_pretty!
+  def test_ordering
+    ary = HEX
+    bad = %w[1 F]
+    exp = <<~EOT
+      01234567         # miss -- level 1 = B, C
+              89ABCDEF # miss
+      0123    89AB     # miss -- level 2 = DF, DG, EF, EG
+      0123        CDEF # HIT!
+      01          CD   # miss -- level 3 = HN, HO
+      01            EF # HIT!
+      0             E  # miss -- level 4 = 0E, 0F, 1E, 1F
+      0              F # miss
+       1            E  # miss
+       1             F # HIT!
+    EOT
+
+    assert_steps ary, bad, exp
+  end
 
   def self.test_find_minimal_combination max, *bad
-    define_method "test_find_minimal_combination_#{max}_#{bad.join "_"}" do
+    define_method "%s_%s_%s" % [__method__, max, bad.join("_")] do
       a = (1..max).to_a
-      _(a.find_minimal_combination(&check(*bad))).must_equal bad
+
+      assert_equal bad, a.find_minimal_combination(&check(*bad))
+    end
+  end
+
+  def self.test_find_minimal_combination_and_count max, nsteps, *bad
+    define_method "%s_%s_%s_%s" % [__method__, max, nsteps, bad.join("_")] do
+      a = (1..max).to_a
+
+      found, count = a.find_minimal_combination_and_count(&check(*bad))
+
+      assert_equal bad, found
+      assert_equal nsteps, count
     end
   end
 
@@ -119,7 +125,14 @@ describe Array, :find_minimal_combination do
   test_find_minimal_combination 1023, 7, 15, 166, 1001
   test_find_minimal_combination 1023, 1000, 1001, 1002
   test_find_minimal_combination 1023, 1001, 1003, 1005, 1007
+  test_find_minimal_combination 1024, 1001, 1003, 1005, 1007
+  test_find_minimal_combination 1024, 1, 1024
+
+  test_find_minimal_combination_and_count 1024, 12, 1, 2
+  test_find_minimal_combination_and_count 1024, 23, 1, 1023
+  test_find_minimal_combination_and_count 1024, 24, 1, 1024
+  test_find_minimal_combination_and_count 1023, 26, 1, 1023
 
-  # test_find_minimal_combination 1024, 1001, 1003, 1005, 1007
-  # test_find_minimal_combination 1023, 1001, 1003, 1005, 1007
+  test_find_minimal_combination_and_count 1024, 93, 1001, 1003, 1005, 1007
+  test_find_minimal_combination_and_count 1023, 93, 1001, 1003, 1005, 1007
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: minitest-bisect
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Ryan Davis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDPjCCAiagAwIBAgIBAzANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
+  MIIDPjCCAiagAwIBAgIBBjANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
   ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
-  GRYDY29tMB4XDTE4MTIwNDIxMzAxNFoXDTE5MTIwNDIxMzAxNFowRTETMBEGA1UE
+  GRYDY29tMB4XDTIxMTIyMzIzMTkwNFoXDTIyMTIyMzIzMTkwNFowRTETMBEGA1UE
   AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
   JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
   b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
@@ -22,14 +22,14 @@ cert_chain:
   qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
   gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
   HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBCwUAA4IB
-  AQCbJwLmpJR2PomLU+Zzw3KRzH/hbyUWc/ftru71AopZ1fy4iY9J/BW5QYKVYwbP
-  V0FSBWtvfI/RdwfKGtuGhPKECZgmLieGuZ3XCc09qPu1bdg7i/tu1p0t0c6163ku
-  nDMDIC/t/DAFK0TY9I3HswuyZGbLW7rgF0DmiuZdN/RPhHq2pOLMLXJmFclCb/im
-  9yToml/06TJdUJ5p64mkBs0TzaK66DIB1Smd3PdtfZqoRV+EwaXMdx0Hb3zdR1JR
-  Em82dBUFsipwMLCYj39kcyHWAxyl6Ae1Cn9r/ItVBCxoeFdrHjfavnrIEoXUt4bU
-  UfBugfLD19bu3nvL+zTAGx/U
+  AQCKB5jfsuSnKb+t/Wrh3UpdkmX7TrEsjVmERC0pPqzQ5GQJgmEXDD7oMgaKXaAq
+  x2m+KSZDrqk7c8uho5OX6YMqg4KdxehfSLqqTZGoeV78qwf/jpPQZKTf+W9gUSJh
+  zsWpo4K50MP+QtdSbKXZwjAafpQ8hK0MnnZ/aeCsW9ov5vdXpYbf3dpg6ADXRGE7
+  lQY2y1tJ5/chqu6h7dQmnm2ABUqx9O+JcN9hbCYoA5i/EeubUEtFIh2w3SpO6YfB
+  JFmxn4h9YO/pVdB962BdBNNDia0kgIjI3ENnkLq0dKpYU3+F3KhEuTksLO0L6X/V
+  YsuyUzsMz6GQA4khyaMgKNSD
   -----END CERTIFICATE-----
-date: 2019-05-27 00:00:00.000000000 Z
+date: 2022-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest-server
@@ -51,14 +51,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -99,14 +99,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.17'
+        version: '3.23'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.17'
+        version: '3.23'
 description: |-
   Hunting down random test failures can be very very difficult,
   sometimes impossible, but minitest-bisect makes it easy.
@@ -160,8 +160,9 @@ files:
 homepage: https://github.com/seattlerb/minitest-bisect
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/seattlerb/minitest-bisect
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -178,8 +179,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
-signing_key: 
+rubygems_version: 3.3.12
+signing_key:
 specification_version: 4
 summary: Hunting down random test failures can be very very difficult, sometimes impossible,
   but minitest-bisect makes it easy