backburner 1.7.0 → 1.8.0

data/test/fixtures/test_queue_settings.rb

@@ -11,4 +11,44 @@ class TestJobSettingsOverride
   queue_garbage_limit 1000
   queue_retry_limit 2
   def self.perform; end
-end
+end
+class TestTubeLimitsJob
+  include Backburner::Queue
+  queue "tube-limits"
+  queue_jobs_limit 5
+  queue_garbage_limit 100
+  queue_retry_limit 3
+  def self.perform; end
+end
+
+# Shares its parent's tube, whose options stay the parent's
+class TestTubeLimitsChildJob < TestTubeLimitsJob
+  queue_jobs_limit 1
+  queue_garbage_limit 7
+end
+
+class TestTubeLimitsLambdaJob
+  include Backburner::Queue
+  queue lambda { |klass| "tube-limits-#{klass.name.downcase}" }
+  queue_jobs_limit 3
+  def self.perform; end
+end
+
+# Gets a tube of its own from the inherited lambda, so its options are its own
+class TestTubeLimitsLambdaChildJob < TestTubeLimitsLambdaJob
+  queue_jobs_limit 4
+end
+
+class TestTubeFewLimitsJob
+  include Backburner::Queue
+  queue "tube-few-limits"
+  queue_retry_limit 2
+  def self.perform; end
+end
+
+# Shares its parent's tube and fills in the limits the parent leaves unset
+class TestTubeFewLimitsChildJob < TestTubeFewLimitsJob
+  queue_jobs_limit 3
+  queue_garbage_limit 50
+  queue_retry_limit 9
+end

data/test/helpers/templogger.rb

@@ -17,6 +17,6 @@ class Templogger
   end
 
   def close
-    @file.close
+    @file.close! # unlink it now: a Tempfile finalizer left for GC calls Process.pid, which some tests mock
   end
 end

data/test/helpers_test.rb

@@ -42,6 +42,19 @@ describe "Backburner::Helpers module" do
       output = exception_message(RuntimeError.new("test"))
       assert_match(/Exception RuntimeError/, output)
     end
+
+    it "shortens the backtrace paths under a working directory that has regexp characters in its name" do
+      ["jobs[1]", "jobs["].each do |name|
+        Dir.mktmpdir do |root|
+          dir = File.join(File.realpath(root), name)
+          Dir.mkdir(dir)
+          error = RuntimeError.new("test")
+          error.set_backtrace(["#{dir}/app/jobs/report.rb:3:in `perform'"])
+          output = Dir.chdir(dir) { exception_message(error) }
+          assert_equal "Exception RuntimeError -> test\n   app/jobs/report.rb:3:in `perform'", output, name
+        end
+      end
+    end
   end # exception_message
 
   describe "for queue_config" do
@@ -85,6 +98,118 @@ describe "Backburner::Helpers module" do
       test = lambda { "email/send_news" }
       assert_equal "test.foo.job.email/send-news", expand_tube_name(test)
     end #lambdas
+
+    it "removes prefix if configured as nil" do
+      Backburner.stubs(:configuration).returns(stub(:tube_namespace => nil, :namespace_separator => '.'))
+
+      test = stub(:queue => "email/send_news")
+      assert_equal "email/send-news", expand_tube_name(test)
+    end
+
+    it "removes prefix if configured as false" do
+      Backburner.stubs(:configuration).returns(stub(:tube_namespace => false, :namespace_separator => '.'))
+
+      test = stub(:queue => "email/send_news")
+      assert_equal "email/send-news", expand_tube_name(test)
+    end
+
+    # Tubes of 1.7.0 with an empty namespace hold queued jobs: keep their names
+    it "starts names with the separator if configured as empty" do
+      Backburner.stubs(:configuration).returns(stub(:tube_namespace => "", :namespace_separator => '.', :primary_queue => "backburner-jobs"))
+
+      assert_equal ".email/send-news", expand_tube_name("email/send_news")
+      assert_equal ".email/send-news", expand_tube_name(stub(:queue => "email/send_news"))
+      assert_equal ".backburner-jobs", expand_tube_name(RuntimeError)
+      assert_equal ".mailers", expand_tube_name("mailers")
+    end
+
+    # A tube name is where queued jobs wait, so a namespace that works keeps every name it gives, including
+    # the odd ones of queue names that start with the namespace ("appmail" -> "app.mail")
+    it "keeps the tube names it gives for namespaces without regexp characters other than dots" do
+      queues = lambda do |namespace, separator|
+        ["default", "mailers", "production_mailers", "newsletter_sender", "email/send_news", "Admin::ReportJob",
+         "#{namespace}mail", "#{namespace}-reports", "#{namespace.tr('.', '-')}-sync", "#{namespace}#{separator}reports"]
+      end
+      {
+        ["backburner.worker.queue", "."] => %w[
+          backburner.worker.queue.default backburner.worker.queue.mailers backburner.worker.queue.production-mailers
+          backburner.worker.queue.newsletter-sender backburner.worker.queue.email/send-news
+          backburner.worker.queue.admin/report-job backburner.worker.queue.mail backburner.worker.queue.-reports
+          backburner.worker.queue.-sync backburner.worker.queue.reports backburner.worker.queue.backburner-jobs
+        ],
+        ["backburner.worker.queue", "_"] => %w[
+          backburner.worker.queue_default backburner.worker.queue_mailers backburner.worker.queue_production-mailers
+          backburner.worker.queue_newsletter-sender backburner.worker.queue_email/send-news
+          backburner.worker.queue_admin/report-job backburner.worker.queue_mail backburner.worker.queue_-reports
+          backburner.worker.queue_-sync backburner.worker.queue_-reports backburner.worker.queue_backburner-jobs
+        ],
+        ["backburner", "."] => %w[
+          backburner.default backburner.mailers backburner.production-mailers backburner.newsletter-sender
+          backburner.email/send-news backburner.admin/report-job backburner.mail backburner.-reports backburner.-sync
+          backburner.reports backburner.-jobs
+        ],
+        ["backburner", "_"] => %w[
+          backburner_default backburner_mailers backburner_production-mailers backburner_newsletter-sender
+          backburner_email/send-news backburner_admin/report-job backburner_mail backburner_-reports backburner_-sync
+          backburner_-reports backburner_-jobs
+        ],
+        ["app", "."] => %w[
+          app.default app.mailers app.production-mailers app.newsletter-sender app.email/send-news app.admin/report-job
+          app.mail app.-reports app.-sync app.reports app.backburner-jobs
+        ],
+        ["app", "_"] => %w[
+          app_default app_mailers app_production-mailers app_newsletter-sender app_email/send-news app_admin/report-job
+          app_mail app_-reports app_-sync app_-reports app_backburner-jobs
+        ],
+        ["app.prod", "."] => %w[
+          app.prod.default app.prod.mailers app.prod.production-mailers app.prod.newsletter-sender
+          app.prod.email/send-news app.prod.admin/report-job app.prod.mail app.prod.-reports app.prod.-sync
+          app.prod.reports app.prod.backburner-jobs
+        ],
+        ["app.prod", "_"] => %w[
+          app.prod_default app.prod_mailers app.prod_production-mailers app.prod_newsletter-sender
+          app.prod_email/send-news app.prod_admin/report-job app.prod_mail app.prod_-reports app.prod_-sync
+          app.prod_-reports app.prod_backburner-jobs
+        ],
+        ["my-app", "."] => %w[
+          my-app.default my-app.mailers my-app.production-mailers my-app.newsletter-sender my-app.email/send-news
+          my-app.admin/report-job my-app.mail my-app.-reports my-app.-sync my-app.reports my-app.backburner-jobs
+        ],
+        ["my-app", "_"] => %w[
+          my-app_default my-app_mailers my-app_production-mailers my-app_newsletter-sender my-app_email/send-news
+          my-app_admin/report-job my-app_mail my-app_-reports my-app_-sync my-app_-reports my-app_backburner-jobs
+        ],
+        ["MyApp", "."] => %w[
+          MyApp.default MyApp.mailers MyApp.production-mailers MyApp.newsletter-sender MyApp.email/send-news
+          MyApp.admin/report-job MyApp.my-appmail MyApp.my-app-reports MyApp.my-app-sync MyApp.my-app.reports
+          MyApp.backburner-jobs
+        ],
+        ["MyApp", "_"] => %w[
+          MyApp_default MyApp_mailers MyApp_production-mailers MyApp_newsletter-sender MyApp_email/send-news
+          MyApp_admin/report-job MyApp_my-appmail MyApp_my-app-reports MyApp_my-app-sync MyApp_my-app-reports
+          MyApp_backburner-jobs
+        ]
+      }.each do |(namespace, separator), tube_names|
+        Backburner.stubs(:configuration).returns(stub(:tube_namespace => namespace, :namespace_separator => separator, :primary_queue => "backburner-jobs"))
+        assert_equal tube_names, queues.call(namespace, separator).map { |queue| expand_tube_name(queue) } + [expand_tube_name(RuntimeError)],
+          [namespace, separator].inspect
+      end
+    end
+
+    it "matches a namespace that isn't a valid regexp literally" do
+      { "app(" => ["app(.default", "app(.mail"], "jobs\\" => ["jobs\\.default", "jobs\\.mail"] }.each do |namespace, tube_names|
+        Backburner.stubs(:configuration).returns(stub(:tube_namespace => namespace, :namespace_separator => ".", :primary_queue => "backburner-jobs"))
+        assert_equal tube_names, [expand_tube_name("default"), expand_tube_name("#{namespace}mail")], namespace
+      end
+    end
+
+    it "uses the bare primary queue without a prefix" do
+      [nil, false].each do |namespace|
+        Backburner.stubs(:configuration).returns(stub(:tube_namespace => namespace, :namespace_separator => '-', :primary_queue => "backburner-jobs"))
+        assert_equal "backburner-jobs", expand_tube_name(RuntimeError), namespace.inspect
+        assert_equal "queue-name", expand_tube_name("queue_name"), namespace.inspect
+      end
+    end
   end # expand_tube_name
 
   describe "for alternative namespace separator" do
@@ -93,6 +218,17 @@ describe "Backburner::Helpers module" do
     it "uses alternative namespace separator" do
       assert_equal "test-queue-name", expand_tube_name("queue_name")
     end # simple string
+
+    it "joins the namespace and queue name without a separator if configured as empty" do
+      Backburner.stubs(:configuration).returns(stub(:tube_namespace => "test", :namespace_separator => '', :primary_queue => "backburner-jobs"))
+      assert_equal "testqueue-name", expand_tube_name("queue_name")
+      assert_equal "testbackburner-jobs", expand_tube_name(RuntimeError)
+    end
+
+    it "keeps a trailing dot in the namespace when the separator is empty" do
+      Backburner.stubs(:configuration).returns(stub(:tube_namespace => "test.", :namespace_separator => '', :primary_queue => "backburner-jobs"))
+      assert_equal "test.queue-name", expand_tube_name("queue_name")
+    end
   end
 
   describe "for resolve_priority method" do
@@ -147,6 +283,31 @@ describe "Backburner::Helpers module" do
     it "supports default pri for null values" do
       assert_equal 1000, resolve_priority(nil)
     end
+
+    it "supports a priority label as the default" do
+      Backburner.configure { |config| config.default_priority = :high }
+      assert_equal 0, resolve_priority(nil)
+      assert_equal 0, resolve_priority(stub(:queue_priority => nil))
+      assert_equal 0, resolve_priority(:unknown_label)
+      assert_equal 200, resolve_priority(:low)
+    end
+
+    it "supports a custom or aliased priority label as the default" do
+      Backburner.configure { |config| config.priority_labels = { :foo => 5, :bar => 'foo' }; config.default_priority = 'bar' }
+      assert_equal 5, resolve_priority(nil)
+    end
+
+    it "leaves an unknown default label as configured" do
+      Backburner.configure { |config| config.default_priority = :unknown_label }
+      assert_equal :unknown_label, resolve_priority(nil)
+    end
+
+    it "stops at a cycle of priority labels" do
+      Backburner.configure { |config| config.priority_labels = { :a => :b, :b => 'a' }; config.default_priority = :a }
+      assert_equal :a, resolve_priority(nil), "a default label cycle is left as configured"
+      Backburner.configure { |config| config.default_priority = 1000 }
+      assert_equal 1000, resolve_priority(:b), "a job label cycle falls back to the default"
+    end
   end # resolve_priority
 
   describe "for resolve_respond_timeout method" do
@@ -178,6 +339,19 @@ describe "Backburner::Helpers module" do
     it "supports default ttr for null values" do
       assert_equal 300, resolve_respond_timeout(nil)
     end
+
+    it "rounds a fractional respond_timeout up to whole seconds, from a value, a class or the default" do
+      assert_equal 1, resolve_respond_timeout(0.2)
+      assert_equal 2, resolve_respond_timeout(stub(:queue_respond_timeout => 1.5))
+      Backburner.configure { |config| config.respond_timeout = 2.5 }
+      assert_equal 3, resolve_respond_timeout(nil)
+    end
+
+    it "keeps an Integer as it is and ignores a value that isn't finite, as before" do
+      assert_equal(-5, resolve_respond_timeout(-5))
+      assert_equal 300, resolve_respond_timeout(Float::INFINITY)
+      assert_equal 300, resolve_respond_timeout(stub(:queue_respond_timeout => Float::NAN))
+    end
   end # resolve_respond_timeout
 
   describe "for resolve_max_job_retries method" do
@@ -218,6 +392,11 @@ describe "Backburner::Helpers module" do
     end
     after { Backburner.configure { |config| config.retry_delay = @original_retry_delay } }
 
+    it "ignores a retry_delay that isn't finite, as before" do
+      assert_equal 300, resolve_retry_delay(stub(:queue_retry_delay => Float::NAN))
+      assert_equal 300, resolve_retry_delay(Float::INFINITY)
+    end
+
     it "supports fix num retry_delay" do
       assert_equal 500, resolve_retry_delay(500)
     end
@@ -240,6 +419,11 @@ describe "Backburner::Helpers module" do
     it "supports default retry_delay for null values" do
       assert_equal 300, resolve_retry_delay(nil)
     end
+
+    it "supports a fractional retry_delay from a value or a class" do
+      assert_equal 2.5, resolve_retry_delay(2.5)
+      assert_equal 1.5, resolve_retry_delay(stub(:queue_retry_delay => 1.5))
+    end
   end # resolve_retry_delay
 
   describe "for resolve_retry_delay_proc method" do

data/test/job_test.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../test_helper', __FILE__)
+require File.expand_path('../fixtures/test_jobs', __FILE__)
 
 module NestedDemo
   class TestJobC
@@ -110,6 +111,27 @@ describe "Backburner::Job module" do
         assert_raises(Backburner::Job::JobNotFound) { @job.process }
       end # error class
     end # invalid
+
+    describe "with a class an autoloader can't load" do
+      before do
+        @task_body = { "class" => "AutoloadingDemo::TestJobGone", "args" => [56] }
+        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
+        @task.expects(:delete).never
+      end
+
+      it "should raise JobNotFound" do
+        @job = Backburner::Job.new(@task)
+        assert_raises(Backburner::Job::JobNotFound) { @job.process }
+      end
+    end # autoloader
+
+    describe "with a class whose file fails to load" do
+      it "should raise JobNotFound naming the cause on one line" do
+        task = stub(:body => { "class" => "TestBrokenNameJob", "args" => [56] }, :ttr => 120, :delete => true, :bury => true)
+        error = assert_raises(Backburner::Job::JobNotFound) { Backburner::Job.new(task).process }
+        assert_match(/\ATestBrokenNameJob \(NameError: uninitialized constant (TestBrokenNameJob::)?TestMissingConcern\)\z/, error.message)
+      end
+    end # broken class file
   end # process
 
   describe "for simple delegation method" do

data/test/logger_test.rb

@@ -41,4 +41,31 @@ describe "Backburner::Logger module" do
       Backburner.configure { |config| config.logger = nil }
     end
   end # log_error
+
+  describe "for log_warn method" do
+    it "prints out to std err" do
+      output = capture_stdout { log_warn("baz") }
+      assert_equal "baz\n", output
+    end
+
+    it "can be configured to log to logger" do
+      Backburner.configure { |config| config.logger = @logger }
+      log_warn("baz")
+      assert_match(/W,.*?baz/, @strio.string)
+    end
+
+    it "logs as an error to a logger without a public warn method" do
+      logged = []
+      logger = Object.new # the README asks a logger for info and error only
+      logger.define_singleton_method(:info) { |msg| logged << [:info, msg] }
+      logger.define_singleton_method(:error) { |msg| logged << [:error, msg] }
+      Backburner.configure { |config| config.logger = logger }
+      log_warn("baz")
+      assert_equal [[:error, "baz"]], logged
+    end
+
+    after do
+      Backburner.configure { |config| config.logger = nil }
+    end
+  end # log_warn
 end

data/test/performable_test.rb

@@ -22,6 +22,24 @@ end
 class AsyncInstanceMethodsTestObj < PerformableTestObj; end
 class AsyncStaticMethodsTestObj < PerformableTestObj; end
 
+class AsyncSettingsTestObj < TestObj
+  include Backburner::Performable
+  queue "performable-settings"
+  queue_priority 10
+  queue_respond_timeout 300
+  queue_max_job_retries 3
+  handle_asynchronously :foo
+  handle_static_asynchronously :bar
+end
+
+class QueueThenPerformableTestObj < TestObj
+  include Backburner::Queue
+  queue "queue-then-performable"
+  queue_priority 20
+  queue_respond_timeout 200
+  include Backburner::Performable
+end
+
 
 
 describe "Backburner::Performable module" do
@@ -84,5 +102,37 @@ describe "Backburner::Performable module" do
       Backburner::Worker.expects(:enqueue).with(AsyncStaticMethodsTestObj, [nil, :bar_without_async, true, false], has_entries(:pri => 5000, :queue => "garply"))
       AsyncStaticMethodsTestObj.bar(true, false)
     end
+
+    describe "on a class with queue settings" do
+      before { clear_jobs!("performable-settings") }
+      after { clear_jobs!("performable-settings") }
+
+      it "keeps the class's queue settings" do
+        assert_equal "performable-settings", AsyncSettingsTestObj.queue
+        assert_equal 10, AsyncSettingsTestObj.queue_priority
+        assert_equal 300, AsyncSettingsTestObj.queue_respond_timeout
+        assert_equal 3, AsyncSettingsTestObj.queue_max_job_retries
+      end
+
+      it "enqueues instance and class method calls with the class's queue settings" do
+        AsyncSettingsTestObj.new.foo(true, false)
+        AsyncSettingsTestObj.bar(false, true)
+        [[56, "foo_without_async", true, false], [nil, "bar_without_async", false, true]].each do |args|
+          pop_one_job("performable-settings") do |job, body|
+            assert_equal ["AsyncSettingsTestObj", args], [body["class"], body["args"]]
+            assert_equal [10, 300], [job.pri, job.ttr]
+            job.delete
+          end
+        end
+      end
+    end
+  end # handle_asynchronously
+
+  describe "when included after Backburner::Queue" do
+    it "keeps the queue settings the class already set" do
+      assert_equal "queue-then-performable", QueueThenPerformableTestObj.queue
+      assert_equal 20, QueueThenPerformableTestObj.queue_priority
+      assert_equal 200, QueueThenPerformableTestObj.queue_respond_timeout
+    end
   end
 end

data/test/queue_test.rb

@@ -5,6 +5,33 @@ module NestedDemo
   class TestJobB; include Backburner::Queue; end
 end
 
+module InheritDemo
+  class ParentJob
+    include Backburner::Queue
+    queue "inherit-parent"
+    queue_priority 10
+    queue_respond_timeout 77
+    queue_max_job_retries 4
+    queue_retry_delay 9
+    queue_retry_delay_proc lambda { |min_retry_delay, num_retries| 42 }
+    queue_jobs_limit 3
+    queue_garbage_limit 50
+    queue_retry_limit 6
+  end
+  class ChildJob < ParentJob; end
+  class GrandchildJob < ChildJob; end
+  class OverrideJob < ParentJob
+    queue "inherit-override"
+    queue_priority 20
+  end
+  class ReincludedJob < ParentJob; include Backburner::Queue; end
+  class LambdaParentJob
+    include Backburner::Queue
+    queue lambda { |klass| klass.name }
+  end
+  class LambdaChildJob < LambdaParentJob; end
+end
+
 describe "Backburner::Queue module" do
   describe "contains known_queue_classes" do
     it "has all defined known queues" do
@@ -66,4 +93,40 @@ describe "Backburner::Queue module" do
       assert_equal retry_delay_proc.call(2, 1), NestedDemo::TestJobB.queue_retry_delay_proc.call(2, 1)
     end
   end # queue_retry_delay_proc
+
+  describe "for subclasses" do
+    settings = [:queue, :queue_priority, :queue_respond_timeout, :queue_max_job_retries, :queue_retry_delay,
+                :queue_retry_delay_proc, :queue_jobs_limit, :queue_garbage_limit, :queue_retry_limit]
+
+    it "inherits every queue setting from the superclass" do
+      settings.each do |setting|
+        refute_nil InheritDemo::ParentJob.send(setting), setting
+        assert_equal InheritDemo::ParentJob.send(setting), InheritDemo::ChildJob.send(setting), setting
+        assert_equal InheritDemo::ParentJob.send(setting), InheritDemo::GrandchildJob.send(setting), setting
+      end
+    end
+
+    it "uses its own settings over inherited ones without changing the superclass" do
+      assert_equal "inherit-override", InheritDemo::OverrideJob.queue
+      assert_equal 20, InheritDemo::OverrideJob.queue_priority
+      assert_equal 77, InheritDemo::OverrideJob.queue_respond_timeout
+      assert_equal "inherit-parent", InheritDemo::ParentJob.queue
+      assert_equal 10, InheritDemo::ParentJob.queue_priority
+    end
+
+    it "inherits the superclass settings when it includes Backburner::Queue again" do
+      assert_equal "inherit-parent", InheritDemo::ReincludedJob.queue
+      assert_equal 10, InheritDemo::ReincludedJob.queue_priority
+    end
+
+    it "calls an inherited queue lambda with the subclass" do
+      assert_equal "InheritDemo::LambdaChildJob", InheritDemo::LambdaChildJob.queue
+    end
+
+    it "registers subclasses as known queue classes, once each" do
+      [InheritDemo::ChildJob, InheritDemo::GrandchildJob, InheritDemo::OverrideJob, InheritDemo::ReincludedJob].each do |klass|
+        assert_equal 1, Backburner::Worker.known_queue_classes.count(klass), klass.name
+      end
+    end
+  end # subclasses
 end # Backburner::Queue

data/test/test_helper.rb

@@ -110,6 +110,34 @@ class MiniTest::Spec
     connection.close if connection
   end
 
+  # A beanstalkd of the test's own (on @port) that it can stop and start, for outage tests:
+  # pick_beanstalkd_port in `before`, then start_beanstalkd, and stop_beanstalkd in `after`
+  def pick_beanstalkd_port
+    @beanstalkd_bin = ENV['BEANSTALKD_BIN'] || ENV['PATH'].split(File::PATH_SEPARATOR).
+      map { |dir| File.join(dir, 'beanstalkd') }.find { |file| File.executable?(file) }
+    skip "needs a beanstalkd binary on PATH or in BEANSTALKD_BIN" unless @beanstalkd_bin
+    server = TCPServer.new('127.0.0.1', 0)
+    @port = server.addr[1]
+    server.close
+  end
+
+  def start_beanstalkd
+    @beanstalkd_pid = Process.spawn(@beanstalkd_bin, '-l', '127.0.0.1', '-p', @port.to_s, [:out, :err] => File::NULL)
+    wait_for { (TCPSocket.new('127.0.0.1', @port).close; true) rescue false }
+  end
+
+  def stop_beanstalkd
+    return unless @beanstalkd_pid
+    Process.kill(:KILL, @beanstalkd_pid)
+    Process.wait(@beanstalkd_pid)
+    @beanstalkd_pid = nil
+  end
+
+  def wait_for(seconds = 15)
+    deadline = Time.now + seconds
+    sleep 0.1 until yield || Time.now > deadline
+  end
+
   # Simulates a broken connection for any Beaneater::Connection. Will
   # simulate a restored connection after `reconnects_after`. This is expected
   # to be used when ensuring a Beaneater connection is open, therefore
@@ -122,4 +150,33 @@ class MiniTest::Spec
     end
     TCPSocket.expects(:new).times(returns.size).returns(*returns)
   end
+
+  # Whether a forked child's GC was disabled by the time the interpreter tore it down (when its
+  # at_exit handlers run). Yields the child's body, which ends as `how` says (:return, :raise, or
+  # :shutdown, which calls Kernel.exit as the TERM and INT traps do); the block forks a child that
+  # runs it and waits for the child. Fails if the GC is already off here (the child would inherit
+  # that), or if the child never ran its at_exit handlers (it left by exit!, or crashed).
+  def gc_disabled_at_child_exit?(worker, how)
+    gc_was_disabled = GC.enable # returns whether it was disabled
+    GC.disable if gc_was_disabled
+    refute gc_was_disabled, "the GC was already disabled in the test process"
+    reader, writer = IO.pipe
+    yield(lambda do
+      reader.close
+      $stdout.reopen(File::NULL)
+      $stderr.reopen(File::NULL)
+      at_exit { writer.write(GC.disable ? "disabled" : "enabled"); writer.close }
+      case how
+      when :raise then raise "the child failed"
+      when :shutdown then worker.shutdown
+      end
+    end)
+    writer.close
+    state = reader.read
+    flunk "the child never ran its at_exit handlers (it left by exit!, or crashed)" if state.empty?
+    state == "disabled"
+  ensure
+    reader.close if reader && !reader.closed?
+    writer.close if writer && !writer.closed?
+  end
 end # MiniTest::Spec