retriable 3.8.0 → 5.0.1

data/spec/retriable_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "rbconfig"
-require "stringio"
 
 describe Retriable do
   let(:time_table_handler) do
@@ -9,7 +8,10 @@ describe Retriable do
   end
 
   before(:each) do
-    described_class.instance_variable_set(:@config, nil)
+    # Reset to a pristine published snapshot, matching what load-time init
+    # publishes. Resetting to nil instead would force #config to carry a
+    # nil-guard that only the suite can reach.
+    described_class.instance_variable_set(:@config, Retriable::Config.new.freeze)
     Thread.current.thread_variable_set(Retriable::OVERRIDE_THREAD_KEY, nil)
     described_class.configure { |c| c.sleep_disabled = true }
     @tries = 0
@@ -26,6 +28,31 @@ describe Retriable do
     raise exception_class, "#{exception_class} occurred"
   end
 
+  # Wall clock appears in the concurrency specs only as a deadlock backstop,
+  # never as a timing assertion. Every worker they start finishes in
+  # milliseconds, so this budget is approached only when a regression leaves a
+  # thread genuinely stuck.
+  let(:deadlock_backstop_seconds) { 10 }
+
+  # Joins each thread within the backstop, failing the example instead of hanging
+  # the suite when one never finishes. A bare Thread#join turns a serialization
+  # regression into a run that never terminates, which CI reports as a timeout
+  # with no failing example to point at.
+  #
+  # The kill matters for the examples that follow: Ruby releases a Mutex held by
+  # a killed thread, so one stuck worker cannot wedge every later `configure`.
+  # Kill is asynchronous, so wait briefly for it to land before failing —
+  # otherwise the mutex is still held when the next example starts.
+  def join_without_deadlock(*threads)
+    threads.flatten.compact.each do |thread|
+      next if thread.join(deadlock_backstop_seconds)
+
+      thread.kill
+      thread.join(1)
+      raise "a worker thread did not finish within #{deadlock_backstop_seconds}s; suspect a deadlock"
+    end
+  end
+
   context "global scope extension" do
     it "cannot be called in the global scope without requiring the core_ext/kernel" do
       script = "require 'retriable'; begin; retriable {}; rescue NoMethodError; exit 0; end; exit 1"
@@ -39,6 +66,49 @@ describe Retriable do
       expect { retriable { increment_tries_with_exception } }.to raise_error(StandardError)
       expect(@tries).to eq(3)
     end
+
+    it "passes on_give_up through the kernel extension" do
+      require_relative "../lib/retriable/core_ext/kernel"
+      received_reason = nil
+      handler = proc { |_e, _try, _elapsed, _interval, reason| received_reason = reason }
+
+      expect { retriable(tries: 1, on_give_up: handler) { increment_tries_with_exception } }
+        .to raise_error(StandardError)
+
+      expect(received_reason).to eq(:tries_exhausted)
+    end
+
+    # These two specs lock in the anonymous block forwarding (`&`) semantics
+    # across both delegation layers: Kernel#retriable_with_context ->
+    # Retriable.with_context. If the `&` is dropped at either layer, the block
+    # is not forwarded and the `block_given?` guard in with_context raises
+    # ArgumentError instead of running the block.
+    it "forwards a block through Kernel#retriable_with_context" do
+      require_relative "../lib/retriable/core_ext/kernel"
+      Retriable.configure { |c| c.contexts[:sql] = { tries: 1 } }
+
+      retriable_with_context(:sql) { increment_tries }
+
+      expect(@tries).to eq(1)
+    end
+
+    it "raises an ArgumentError when Kernel#retriable_with_context is called without a block" do
+      require_relative "../lib/retriable/core_ext/kernel"
+      Retriable.configure { |c| c.contexts[:sql] = { tries: 1 } }
+
+      expect { retriable_with_context(:sql) }
+        .to raise_error(ArgumentError, /with_context requires a block/)
+      expect(@tries).to eq(0)
+    end
+
+    it "is not callable with an explicit receiver" do
+      require_relative "../lib/retriable/core_ext/kernel"
+
+      expect { "foo".retriable { increment_tries } }
+        .to raise_error(NoMethodError, /private method/)
+      expect { "foo".retriable_with_context(:sql) { increment_tries } }
+        .to raise_error(NoMethodError, /private method/)
+    end
   end
 
   context "#retriable" do
@@ -51,9 +121,6 @@ describe Retriable do
 
     it "raises a LocalJumpError if not given a block" do
       expect { described_class.retriable }.to raise_error(LocalJumpError)
-      expect do
-        expect { described_class.retriable(timeout: 2) }.to raise_error(LocalJumpError)
-      end.to output(/timeout.*deprecated.*Retriable 4\.0/i).to_stderr
     end
 
     it "stops at first try if the block does not raise an exception" do
@@ -66,6 +133,19 @@ describe Retriable do
       expect(@tries).to eq(3)
     end
 
+    it "re-raises StopIteration after the configured tries" do
+      failure = StopIteration.new("end of input")
+
+      expect do
+        described_class.retriable(tries: 2) do
+          increment_tries
+          raise failure
+        end
+      end.to(raise_error { |error| expect(error).to equal(failure) })
+
+      expect(@tries).to eq(2)
+    end
+
     it "makes only 1 try when exception raised is not descendent of StandardError" do
       expect do
         described_class.retriable { increment_tries_with_exception(NonStandardError) }
@@ -171,86 +251,8 @@ describe Retriable do
       end.to raise_error(ArgumentError, /tries/)
     end
 
-    it "will timeout after 1 second" do
-      expect do
-        expect { described_class.retriable(timeout: 1) { sleep(1.1) } }.to raise_error(Timeout::Error)
-      end.to output(/timeout.*deprecated.*Retriable 4\.0/i).to_stderr
-    end
-
-    context "timeout: deprecation" do
-      it "warns at most once per process across repeated retriable calls" do
-        original_stderr = $stderr
-        stderr = StringIO.new
-        begin
-          $stderr = stderr
-
-          described_class.retriable(timeout: 5) { :noop }
-          described_class.retriable(timeout: 5) { :noop }
-          described_class.retriable(timeout: 5) { :noop }
-
-          expect(stderr.string.scan("timeout:` option is deprecated").size).to eq(1)
-        ensure
-          $stderr = original_stderr
-        end
-      end
-
-      it "warns when timeout is passed to retriable" do
-        expect do
-          described_class.retriable(timeout: 5) { :noop }
-        end.to output(/timeout.*deprecated.*Retriable 4\.0/i).to_stderr
-      end
-
-      it "keeps applying timeout while deprecated" do
-        original_stderr = $stderr
-        begin
-          $stderr = StringIO.new
-          expect do
-            described_class.retriable(timeout: 0.05, tries: 1) { sleep(0.5) }
-          end.to raise_error(Timeout::Error)
-        ensure
-          $stderr = original_stderr
-        end
-      end
-
-      it "warns when timeout is supplied through with_override" do
-        expect do
-          described_class.with_override(timeout: 5) do
-            described_class.retriable { :noop }
-          end
-        end.to output(/timeout.*deprecated.*Retriable 4\.0/i).to_stderr
-      end
-
-      it "warns when timeout is supplied through configure" do
-        original_config = described_class.config
-        begin
-          expect do
-            described_class.configure { |config| config.timeout = 5 }
-            described_class.retriable { :noop }
-          end.to output(/timeout.*deprecated.*Retriable 4\.0/i).to_stderr
-        ensure
-          described_class.configure do |config|
-            original_config.to_h.each { |key, value| config.public_send("#{key}=", value) }
-          end
-        end
-      end
-
-      it "is silenced by Warning[:deprecated] = false", if: WARN_CATEGORY_SUPPORTED do
-        original = Warning[:deprecated]
-        begin
-          Warning[:deprecated] = false
-          expect do
-            described_class.retriable(timeout: 5) { :noop }
-          end.not_to output.to_stderr
-        ensure
-          Warning[:deprecated] = original
-        end
-      end
-
-      it "does not warn when timeout is absent" do
-        expect do
-          described_class.retriable { :noop }
-        end.not_to output.to_stderr
-      end
+    it "rejects timeout as an unknown option" do
+      expect { described_class.retriable(timeout: 1) { :noop } }.to raise_error(ArgumentError, /not a valid option/)
     end
 
     it "applies a randomized exponential backoff to each try" do
@@ -296,6 +298,187 @@ describe Retriable do
       end
     end
 
+    it "does not call on_retry when explicitly set to nil" do
+      callback_called = false
+      original_on_retry = described_class.config.on_retry
+
+      begin
+        described_class.configure do |c|
+          c.on_retry = proc { |_exception, _try, _elapsed_time, _next_interval| callback_called = true }
+        end
+
+        expect do
+          described_class.retriable(on_retry: nil, tries: 3) { increment_tries_with_exception }
+        end.to raise_error(StandardError)
+
+        expect(@tries).to eq(3)
+        expect(callback_called).to be(false)
+      ensure
+        described_class.configure do |c|
+          c.on_retry = original_on_retry
+        end
+      end
+    end
+
+    it "calls on_give_up with max elapsed time details before re-raising" do
+      described_class.configure { |c| c.sleep_disabled = false }
+      give_up_calls = []
+      on_give_up = proc do |exception, try, elapsed_time, next_interval, reason|
+        give_up_calls << [exception, try, elapsed_time, next_interval, reason]
+      end
+
+      expect do
+        described_class.retriable(
+          intervals: [1.0, 1.0],
+          max_elapsed_time: 0.5,
+          on_give_up: on_give_up,
+        ) do
+          increment_tries_with_exception
+        end
+      end.to raise_error(StandardError)
+
+      exception, try, elapsed_time, next_interval, reason = give_up_calls.fetch(0)
+      expect(give_up_calls.size).to eq(1)
+      expect(exception).to be_a(StandardError)
+      expect(exception.message).to eq("StandardError occurred")
+      expect(try).to eq(1)
+      expect(elapsed_time).to be >= 0
+      expect(next_interval).to eq(1.0)
+      expect(reason).to eq(:max_elapsed_time)
+      expect(@tries).to eq(1)
+    end
+
+    it "calls on_give_up with tries exhausted details before re-raising" do
+      give_up_calls = []
+      on_give_up = proc do |exception, try, elapsed_time, next_interval, reason|
+        give_up_calls << [exception, try, elapsed_time, next_interval, reason]
+      end
+
+      expect do
+        described_class.retriable(tries: 2, on_give_up: on_give_up) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      exception, try, elapsed_time, next_interval, reason = give_up_calls.fetch(0)
+      expect(give_up_calls.size).to eq(1)
+      expect(exception).to be_a(StandardError)
+      expect(exception.message).to eq("StandardError occurred")
+      expect(try).to eq(2)
+      expect(elapsed_time).to be >= 0
+      expect(next_interval).to be_nil
+      expect(reason).to eq(:tries_exhausted)
+      expect(@tries).to eq(2)
+    end
+
+    it "does not call on_give_up when the block eventually succeeds" do
+      callback_called = false
+
+      described_class.retriable(tries: 3, on_give_up: proc { callback_called = true }) do
+        increment_tries
+        raise StandardError if @tries < 2
+      end
+
+      expect(callback_called).to be(false)
+      expect(@tries).to eq(2)
+    end
+
+    it "does not call on_give_up for non-retriable exception types" do
+      callback_called = false
+
+      expect do
+        described_class.retriable(on_give_up: proc { callback_called = true }) do
+          increment_tries_with_exception(NonStandardError)
+        end
+      end.to raise_error(NonStandardError)
+
+      expect(callback_called).to be(false)
+      expect(@tries).to eq(1)
+    end
+
+    it "does not call on_give_up when retry_if rejects the exception" do
+      callback_called = false
+
+      expect do
+        described_class.retriable(
+          tries: 3,
+          retry_if: ->(_exception) { false },
+          on_give_up: proc { callback_called = true },
+        ) do
+          increment_tries_with_exception
+        end
+      end.to raise_error(StandardError)
+
+      expect(callback_called).to be(false)
+      expect(@tries).to eq(1)
+    end
+
+    it "does not call on_give_up when explicitly set to false" do
+      callback_called = false
+      original_on_give_up = described_class.config.on_give_up
+
+      begin
+        described_class.configure do |c|
+          c.on_give_up = proc { callback_called = true }
+        end
+
+        expect do
+          described_class.retriable(on_give_up: false, tries: 1) { increment_tries_with_exception }
+        end.to raise_error(StandardError)
+
+        expect(callback_called).to be(false)
+      ensure
+        described_class.configure do |c|
+          c.on_give_up = original_on_give_up
+        end
+      end
+    end
+
+    it "does not call on_give_up when explicitly set to nil" do
+      callback_called = false
+      original_on_give_up = described_class.config.on_give_up
+
+      begin
+        described_class.configure do |c|
+          c.on_give_up = proc { callback_called = true }
+        end
+
+        expect do
+          described_class.retriable(on_give_up: nil, tries: 1) { increment_tries_with_exception }
+        end.to raise_error(StandardError)
+
+        expect(callback_called).to be(false)
+      ensure
+        described_class.configure do |c|
+          c.on_give_up = original_on_give_up
+        end
+      end
+    end
+
+    it "calls on_retry before on_give_up when giving up" do
+      events = []
+
+      expect do
+        described_class.retriable(
+          tries: 1,
+          on_retry: proc { events << :on_retry },
+          on_give_up: proc { events << :on_give_up },
+        ) do
+          increment_tries_with_exception
+        end
+      end.to raise_error(StandardError)
+
+      expect(events).to eq(%i[on_retry on_give_up])
+    end
+
+    it "propagates exceptions raised inside on_give_up, replacing the original exception" do
+      handler = proc { raise "handler exploded" }
+
+      expect do
+        described_class.retriable(tries: 1, on_give_up: handler) { increment_tries_with_exception }
+      end.to raise_error(RuntimeError, "handler exploded")
+
+      expect(@tries).to eq(1)
+    end
+
     context "with rand_factor 0.0 and an on_retry handler" do
       let(:tries) { 6 }
       let(:no_rand_timetable) { { 1 => 0.5, 2 => 0.75, 3 => 1.125 } }
@@ -375,6 +558,19 @@ describe Retriable do
       end
     end
 
+    context "with a Set :on parameter" do
+      it "retries each exception class in the Set" do
+        described_class.retriable(on: Set[StandardError, NonStandardError]) do
+          increment_tries
+
+          raise StandardError if @tries == 1
+          raise NonStandardError if @tries == 2
+        end
+
+        expect(@tries).to eq(3)
+      end
+    end
+
     context "with a hash :on parameter" do
       let(:on_hash) { { NonStandardError => /NonStandardError occurred/ } }
 
@@ -407,6 +603,20 @@ describe Retriable do
         expect(@tries).to eq(1)
       end
 
+      it "does not call on_give_up when exception class matches but message does not" do
+        callback_called = false
+
+        expect do
+          described_class.retriable(on: on_hash, on_give_up: proc { callback_called = true }) do
+            increment_tries
+            raise SecondNonStandardError, "not a match"
+          end
+        end.to raise_error(SecondNonStandardError, /not a match/)
+
+        expect(callback_called).to be(false)
+        expect(@tries).to eq(1)
+      end
+
       it "successfully retries when the values are arrays of exception message patterns" do
         exceptions = []
         handler = ->(exception, try, _elapsed_time, _next_interval) { exceptions[try] = exception }
@@ -599,6 +809,274 @@ describe Retriable do
     it "raises NoMethodError on invalid configuration" do
       expect { described_class.configure { |c| c.does_not_exist = 123 } }.to raise_error(NoMethodError)
     end
+
+    it "returns the configure block's result" do
+      result = described_class.configure do |c|
+        c.tries = 7
+        :configured
+      end
+
+      expect(result).to eq(:configured)
+      expect(described_class.config.tries).to eq(7)
+    end
+  end
+
+  context "#configure thread safety (copy-on-write)" do
+    it "eagerly initializes @config at load time, before any configure/config call" do
+      script = "require 'retriable'; " \
+               "exit(Retriable.instance_variable_get(:@config).is_a?(Retriable::Config) ? 0 : 1)"
+      expect(system(RbConfig.ruby, "-Ilib", "-e", script)).to be(true)
+    end
+
+    it "publishes a new Config object on configure instead of mutating in place" do
+      before = described_class.config
+      described_class.configure { |c| c.tries = 7 }
+      after = described_class.config
+
+      expect(after).not_to equal(before)
+      expect(after.tries).to eq(7)
+      expect(before.tries).not_to eq(7)
+    end
+
+    it "keeps an already-captured snapshot stable across later configures" do
+      described_class.configure { |c| c.contexts[:sql] = { tries: 1 } }
+      snapshot = described_class.config
+
+      described_class.configure { |c| c.contexts[:http] = { tries: 2 } }
+      described_class.configure { |c| c.contexts[:sql][:tries] = 99 }
+
+      expect(snapshot.contexts).to eq(sql: { tries: 1 })
+    end
+
+    it "publishes a frozen snapshot, so direct mutation fails loudly" do
+      described_class.configure { |c| c.contexts[:api] = { tries: 1 } }
+
+      expect { described_class.config.tries = 99 }.to raise_error(FrozenError)
+      expect { described_class.config.contexts[:api][:tries] = 99 }.to raise_error(FrozenError)
+      expect(described_class.config.contexts[:api]).to eq(tries: 1)
+    end
+
+    it "still hands the configure block a mutable candidate" do
+      expect do
+        described_class.configure do |c|
+          c.contexts[:api] = { tries: 1 }
+          c.contexts[:api][:tries] = 2
+          c.on = [StandardError]
+          c.on << ArgumentError
+        end
+      end.not_to raise_error
+
+      expect(described_class.config.contexts[:api]).to eq(tries: 2)
+    end
+
+    it "does not freeze collections the caller still owns" do
+      caller_owned = [StandardError]
+
+      described_class.configure { |c| c.on = caller_owned }
+
+      expect(caller_owned).not_to be_frozen
+      expect(described_class.config.on).to be_frozen
+      expect(described_class.config.on).not_to equal(caller_owned)
+    end
+
+    it "owns and freezes a copy of a mutable Hash default" do
+      fallback = []
+      contexts = Hash.new(fallback)
+      contexts[:api] = { tries: 1 }
+
+      described_class.configure { |c| c.contexts = contexts }
+      published_default = described_class.config.contexts.default
+
+      expect(published_default).not_to equal(fallback)
+      expect(published_default).to be_frozen
+      expect(fallback).not_to be_frozen
+    end
+
+    it "does not let a published default leak mutations into the caller's object" do
+      fallback = []
+      described_class.configure { |c| c.contexts = Hash.new(fallback) }
+
+      expect { described_class.config.contexts[:absent] << :leaked }.to raise_error(FrozenError)
+      expect(fallback).to be_empty
+    end
+
+    it "does not drop updates when configured concurrently from many threads" do
+      keys = (0...50).map { |i| :"ctx_#{i}" }
+      release = Queue.new
+
+      threads = keys.map do |key|
+        Thread.new do
+          release.pop
+          described_class.configure { |c| c.contexts[key] = { tries: 1 } }
+        end
+      end
+
+      keys.size.times { release << true }
+      join_without_deadlock(threads)
+
+      expect(described_class.config.contexts.keys).to match_array(keys)
+    end
+
+    it "lets nested configure calls join the outer transaction" do
+      inner_candidate = nil
+
+      result = described_class.configure do |outer|
+        outer.tries = 7
+        nested_result = described_class.configure do |inner|
+          inner_candidate = inner
+          inner.base_interval = 1
+          :nested_result
+        end
+
+        expect(nested_result).to eq(:nested_result)
+        expect(inner_candidate).to equal(outer)
+        :outer_result
+      end
+
+      expect(result).to eq(:outer_result)
+      expect(described_class.config.tries).to eq(7)
+      expect(described_class.config.base_interval).to eq(1)
+    end
+
+    it "rolls back nested changes when the outer configure raises" do
+      described_class.configure { |c| c.tries = 4 }
+
+      expect do
+        described_class.configure do |outer|
+          outer.tries = 7
+          described_class.configure { |inner| inner.base_interval = 1 }
+          raise "outer failed"
+        end
+      end.to raise_error(RuntimeError, "outer failed")
+
+      expect(described_class.config.tries).to eq(4)
+      expect(described_class.config.base_interval).to eq(0.5)
+    end
+
+    it "lets configure calls from a fiber join the outer transaction" do
+      described_class.configure do |outer|
+        fiber_candidate = Fiber.new do
+          described_class.configure do |inner|
+            inner.tries = 9
+            inner
+          end
+        end.resume
+
+        expect(fiber_candidate).to equal(outer)
+      end
+
+      expect(described_class.config.tries).to eq(9)
+    end
+
+    it "exposes the in-progress config to the configuring thread" do
+      described_class.configure do |c|
+        c.tries = 7
+        expect(described_class.config.tries).to eq(7)
+      end
+
+      expect(described_class.config.tries).to eq(7)
+    end
+
+    it "uses the in-progress config for retriable" do
+      attempts = 0
+
+      described_class.configure do |c|
+        c.tries = 1
+        c.sleep_disabled = true
+
+        expect do
+          described_class.retriable do
+            attempts += 1
+            raise StandardError
+          end
+        end.to raise_error(StandardError)
+      end
+
+      expect(attempts).to eq(1)
+    end
+
+    it "uses candidate-only contexts for with_context" do
+      described_class.configure do |c|
+        c.contexts[:candidate] = { tries: 1 }
+
+        expect(described_class.with_context(:candidate) { :found }).to eq(:found)
+      end
+    end
+
+    it "shares the in-progress config with fibers in the configuring thread" do
+      described_class.configure do |c|
+        c.tries = 7
+
+        expect(Fiber.new { described_class.config.tries }.resume).to eq(7)
+      end
+    end
+
+    it "does not block readers while configure is in progress" do
+      published_tries = described_class.config.tries
+      published_base_interval = described_class.config.base_interval
+      configuring = Queue.new
+      release = Queue.new
+      writer = Thread.new do
+        described_class.configure do |c|
+          c.tries = published_tries + 1
+          described_class.configure { |inner| inner.base_interval = published_base_interval + 1 }
+          configuring << true
+          release.pop
+        end
+      end
+      reader = nil
+
+      begin
+        configuring.pop
+        reader = Thread.new do
+          snapshot = described_class.config
+          [snapshot.tries, snapshot.base_interval]
+        end
+        # The timeout is a deadlock backstop, not the assertion. A reader that
+        # is not blocked returns immediately, so this budget is only ever
+        # approached if #config starts waiting on the in-progress #configure.
+        expect(reader.join(deadlock_backstop_seconds)).to be(reader),
+                                                          "reader blocked while configure was in progress"
+        # Thread#value re-raises anything the reader raised, so a broken reader
+        # fails loudly instead of hanging on an empty queue.
+        expect(reader.value).to eq([published_tries, published_base_interval])
+      ensure
+        release << true
+        join_without_deadlock(writer, reader)
+      end
+    end
+  end
+
+  context "#retriable tries/intervals precedence" do
+    it "lets a per-call tries clear globally configured intervals" do
+      described_class.configure { |c| c.intervals = [0.5, 1.0] }
+
+      expect do
+        described_class.retriable(tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(1)
+    end
+
+    it "still lets per-call intervals win when both intervals and tries are given" do
+      expect do
+        described_class.retriable(intervals: [0.5, 1.0], tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(3) # intervals.size + 1
+    end
+
+    it "lets a with_context tries clear context intervals" do
+      described_class.configure do |c|
+        c.contexts[:api] = { intervals: [0.5, 1.0] }
+      end
+
+      expect do
+        described_class.with_context(:api, tries: 1) { increment_tries_with_exception }
+      end.to raise_error(StandardError)
+
+      expect(@tries).to eq(1)
+    end
   end
 
   context "#with_override" do
@@ -737,17 +1215,15 @@ describe Retriable do
     end
 
     it "treats non-hash configured contexts as empty when override contexts are hash" do
-      begin
-        described_class.configure { |c| c.contexts = nil }
+      described_class.configure { |c| c.contexts = nil }
 
-        described_class.with_override(contexts: { api: { tries: 1 } }) do
-          described_class.with_context(:api) { increment_tries }
-        end
-
-        expect(@tries).to eq(1)
-      ensure
-        described_class.configure { |c| c.contexts = {} }
+      described_class.with_override(contexts: { api: { tries: 1 } }) do
+        described_class.with_context(:api) { increment_tries }
       end
+
+      expect(@tries).to eq(1)
+    ensure
+      described_class.configure { |c| c.contexts = {} }
     end
 
     it "ignores nil override contexts values in with_context" do
@@ -921,7 +1397,7 @@ describe Retriable do
 
       2.times { ready.pop }
       2.times { proceed << true }
-      threads.each(&:join)
+      join_without_deadlock(threads)
 
       expect(results).to eq(1 => 1, 2 => 2)
     end
@@ -952,7 +1428,7 @@ describe Retriable do
         sibling_done << true
       end
 
-      [setter, sibling].each(&:join)
+      join_without_deadlock(setter, sibling)
       expect(sibling_tries).to eq(3)
     end
 
@@ -960,7 +1436,7 @@ describe Retriable do
       child_tries = nil
 
       described_class.with_override(tries: 1) do
-        Thread.new do
+        child = Thread.new do
           tries = 0
           begin
             described_class.retriable(tries: 3) do
@@ -970,7 +1446,8 @@ describe Retriable do
           rescue StandardError
             child_tries = tries
           end
-        end.join
+        end
+        join_without_deadlock(child)
       end
 
       expect(child_tries).to eq(3)
@@ -979,7 +1456,7 @@ describe Retriable do
     it "shares the active override with fibers in the same thread" do
       fiber_tries = nil
 
-      Thread.new do
+      worker = Thread.new do
         described_class.with_override(tries: 1) do
           Fiber.new do
             tries = 0
@@ -993,7 +1470,8 @@ describe Retriable do
             end
           end.resume
         end
-      end.join
+      end
+      join_without_deadlock(worker)
 
       expect(fiber_tries).to eq(1)
     end
@@ -1002,7 +1480,7 @@ describe Retriable do
       other_thread_tries = nil
 
       described_class.with_override(tries: 1) do
-        Thread.new do
+        other = Thread.new do
           tries = 0
           begin
             described_class.retriable(tries: 3) do
@@ -1012,11 +1490,37 @@ describe Retriable do
           rescue StandardError
             other_thread_tries = tries
           end
-        end.join
+        end
+        join_without_deadlock(other)
       end
 
       expect(other_thread_tries).to eq(3)
     end
+
+    it "applies overridden on_give_up handlers" do
+      callback_called = false
+
+      expect do
+        described_class.with_override(on_give_up: proc { callback_called = true }) do
+          described_class.retriable(tries: 1) { increment_tries_with_exception }
+        end
+      end.to raise_error(StandardError)
+
+      expect(callback_called).to be(true)
+    end
+
+    it "applies on_give_up handlers configured via per-context overrides" do
+      received_reason = nil
+      handler = proc { |_e, _try, _elapsed, _interval, reason| received_reason = reason }
+
+      expect do
+        described_class.with_override(contexts: { api: { tries: 1, on_give_up: handler } }) do
+          described_class.with_context(:api) { increment_tries_with_exception }
+        end
+      end.to raise_error(StandardError)
+
+      expect(received_reason).to eq(:tries_exhausted)
+    end
   end
 
   context "#with_context" do
@@ -1034,8 +1538,15 @@ describe Retriable do
       expect(@tries).to eq(1)
     end
 
-    it "returns nil when called without a block" do
-      expect(described_class.with_context(:sql)).to be_nil
+    it "raises an ArgumentError when called without a block" do
+      expect { described_class.with_context(:sql) }
+        .to raise_error(ArgumentError, /with_context requires a block/)
+      expect(@tries).to eq(0)
+    end
+
+    it "checks for a block before looking up the context" do
+      expect { described_class.with_context(:missing) }
+        .to raise_error(ArgumentError, /with_context requires a block/)
       expect(@tries).to eq(0)
     end
 
@@ -1075,5 +1586,56 @@ describe Retriable do
       described_class.with_context(:broken) { increment_tries }
       expect(@tries).to eq(1)
     end
+
+    it "surfaces an invalid context on any retriable call before that context is used" do
+      described_class.configure { |c| c.contexts[:unused] = { contexts: {} } }
+
+      expect { described_class.retriable { :ok } }
+        .to raise_error(ArgumentError, /contexts is not a valid option/)
+    end
+
+    it "invokes on_give_up configured on a context" do
+      callback_called = false
+      described_class.configure do |c|
+        c.contexts[:flaky] = { tries: 1, on_give_up: proc { callback_called = true } }
+      end
+
+      expect { described_class.with_context(:flaky) { increment_tries_with_exception } }
+        .to raise_error(StandardError)
+
+      expect(callback_called).to be(true)
+    end
+
+    it "resolves the context against a single config snapshot" do
+      with_ctx = Retriable::Config.new(sleep_disabled: true, contexts: { api: { tries: 1 } })
+      without_ctx = Retriable::Config.new(sleep_disabled: true)
+
+      # Simulate a concurrent #configure publishing a new config between
+      # with_context's existence check and its option resolution: the first
+      # config read sees the context, later reads do not. with_context must
+      # read config once so the context options are never silently dropped.
+      allow(described_class).to receive(:config).and_return(with_ctx, without_ctx)
+
+      expect { described_class.with_context(:api) { increment_tries_with_exception } }
+        .to raise_error(StandardError)
+
+      expect(@tries).to eq(1)
+    end
+
+    it "resolves global options against the same snapshot used for the context" do
+      special_error = Class.new(StandardError)
+      with_ctx = Retriable::Config.new(sleep_disabled: true, on: [special_error], contexts: { api: { tries: 2 } })
+      swapped = Retriable::Config.new(sleep_disabled: true, on: [ArgumentError])
+
+      # A concurrent #configure swaps the global config (here, the retriable
+      # `on` list) after with_context has captured its snapshot. The whole
+      # context execution must use the captured snapshot, not the swapped one.
+      allow(described_class).to receive(:config).and_return(with_ctx, swapped)
+
+      expect { described_class.with_context(:api) { increment_tries_with_exception(special_error) } }
+        .to raise_error(special_error)
+
+      expect(@tries).to eq(2)
+    end
   end
 end