Improve branch coverage for exceptions, namespace, router, testing and translation utilities

Adds direct unit tests to exercise previously-uncovered branches:
- Grape::Exceptions::Base#translate_message (Proc/Hash-pattern/plain-value branches, and the Hash-without-:key error case)
- Grape::Exceptions::RequestError (new spec file)
- Grape::Exceptions::Validation (message omitted case)
- Grape::Middleware::Base (instance-level #default_options fallback)
- Grape::Middleware::Error (#resolved_backtrace fallback chain, InvalidVersionHeader precedence)
- Grape::Middleware::Stack::Middleware#== (non-Middleware/non-Class comparison)
- Grape::Middleware::Versioner::Header (skips media-type matching without a vendor)
- Grape::Namespace.joined_space
- Grape::Router::BaseRoute#initialize (ActiveSupport::OrderedOptions wrapping)
- Grape::Router::MustermannPattern (:param capture syntax, Integer vs. default constraint)
- Grape::Router::Pattern::Path#suffix (non-path versioning)
- Grape::Testing (missing block / no registered hooks)
- Grape::Util::Translation#translate (explicit locale / explicit default / fallback-locale retry)

Also marks one genuinely unreachable branch (comment-only, not deleted,
per project convention):
- Grape::DSL::Routing#version's trailing `@versions&.last` — @versions
  is unconditionally reassigned to an Array a few lines above, so the
  `&.` can never see nil.

Raises the full-matrix branch coverage from 95.58% (1278/1337) to
96.85% (1324/1367), while keeping line coverage at 100%. Not aiming for
100% branch coverage; only the easy, high-signal gaps were closed.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: dblock

CHANGELOG.md

@@ -70,6 +70,7 @@
 * [#2895](https://github.com/ruby-grape/grape/pull/2895): Cut per-request work out of the endpoint, validation and router paths: scan the router's compiled union by capture number rather than by name, skip the Array boxing in `AttributesIterator` for a flat scope, read a coerced attribute once instead of three times, and resolve the formatter's config and the coercers' type checks once at build time - [@ericproulx](https://github.com/ericproulx).
 * [#2900](https://github.com/ruby-grape/grape/pull/2900): Remove the deprecations announced in 3.2 and 3.3: `Grape::Router.normalize_path`, Hash access on middleware `Options` and their `DEFAULT_OPTIONS` constants, the positional options Hash for `auth`/`http_basic`/`desc`, a Hash returned from a `rescue_from` handler, and `@option` on validators (see UPGRADING) - [@ericproulx](https://github.com/ericproulx).
 * [#2896](https://github.com/ruby-grape/grape/pull/2896): Bring test suite line coverage to 100% - [@dblock](https://github.com/dblock).
+* [#2897](https://github.com/ruby-grape/grape/pull/2897): Improve test suite branch coverage - [@dblock](https://github.com/dblock).
 * Your contribution here.
 
 #### Fixes

spec/grape/exceptions/base_spec.rb

@@ -136,4 +136,40 @@
       end
     end
   end
+
+  describe '#translate_message (private)' do
+    subject(:translate_message) { described_class.new.__send__(:translate_message, translation_key) }
+
+    context 'when given a Proc' do
+      let(:translation_key) { -> { 'from a proc' } }
+
+      it 'calls the Proc' do
+        expect(translate_message).to eq('from a proc')
+      end
+    end
+
+    context 'when given a Hash matching {key:, **opts}' do
+      let(:translation_key) { { key: :invalid_formatter, klass: String, to_format: 'xml' } }
+
+      it 'translates using the key and forwards the remaining pairs as opts' do
+        expect(translate_message).to eq('cannot convert String to xml')
+      end
+    end
+
+    context 'when given a Hash that does not have a :key entry' do
+      let(:translation_key) { { klass: String, to_format: 'xml' } }
+
+      it 'raises NoMatchingPatternKeyError' do
+        expect { translate_message }.to raise_error(NoMatchingPatternKeyError)
+      end
+    end
+
+    context 'when given anything else (e.g. a plain String)' do
+      let(:translation_key) { 'a literal message' }
+
+      it 'returns it unchanged' do
+        expect(translate_message).to eq('a literal message')
+      end
+    end
+  end
 end

spec/grape/exceptions/request_error_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+describe Grape::Exceptions::RequestError do
+  describe '#initialize' do
+    context 'when raised inside a rescue block' do
+      it 'captures the current exception message' do
+        error = begin
+          raise 'boom'
+        rescue RuntimeError
+          described_class.new
+        end
+        expect(error.message).to eq('boom')
+      end
+    end
+
+    context 'when there is no current exception' do
+      it 'has no message from a prior exception' do
+        # $ERROR_INFO ($!) is read-only and only set by an active rescue, so
+        # simulate "no exception" the same way: outside any rescue block.
+        # `StandardError#message` defaults to the class name when no message
+        # was given, so this pins the $ERROR_INFO&.message safe-nav's nil case.
+        expect(described_class.new.message).to eq(described_class.name)
+      end
+    end
+
+    it 'defaults status to 400' do
+      expect(described_class.new.status).to eq(400)
+    end
+
+    it 'accepts a custom status' do
+      expect(described_class.new(status: 422).status).to eq(422)
+    end
+  end
+end

spec/grape/exceptions/validation_spec.rb

@@ -5,6 +5,18 @@
     expect { described_class.new(message: 'presence') }.to raise_error(ArgumentError, /missing keyword:.+?params/)
   end
 
+  context 'when message is omitted' do
+    subject(:error) { described_class.new(params: ['id']) }
+
+    it 'has a nil message_key' do
+      expect(error.message_key).to be_nil
+    end
+
+    it 'has no message from the given options' do
+      expect(error.message).to eq(described_class.name)
+    end
+  end
+
   context 'when message is a Symbol' do
     subject(:error) { described_class.new(params: ['id'], message: :presence) }
 

spec/grape/middleware/base_spec.rb

@@ -189,6 +189,24 @@
       end
     end
 
+    context 'when a middleware defines an instance-level #default_options' do
+      let(:example_ware) do
+        Class.new(Grape::Middleware::Base) do
+          def default_options
+            { monkey: true }
+          end
+        end
+      end
+
+      it 'merges options through the instance method instead of a constant' do
+        expect(example_ware.new(blank_app).options[:monkey]).to be true
+      end
+
+      it 'overrides default options when provided' do
+        expect(example_ware.new(blank_app, monkey: false).options[:monkey]).to be false
+      end
+    end
+
     context 'when a middleware declares its own Options Data class' do
       let(:example_ware) do
         Class.new(Grape::Middleware::Base) do

spec/grape/middleware/error_spec.rb

@@ -488,4 +488,34 @@ def initialize
       expect(middleware.__send__(:error?, 'not an error')).to be false
     end
   end
+
+  describe '#resolved_backtrace' do
+    subject(:middleware) { described_class.new(->(_env) {}, rescue_options: Grape::DSL::RescueOptions.new(backtrace: true)) }
+
+    context 'when the raw response has no backtrace of its own' do
+      it 'falls back to the original exception backtrace' do
+        original_exception = RuntimeError.new('boom')
+        original_exception.set_backtrace(['original.rb:1'])
+        raw = Grape::Exceptions::ErrorResponse.new(original_exception:)
+
+        expect(middleware.__send__(:resolved_backtrace, raw)).to eq(['original.rb:1'])
+      end
+    end
+
+    context 'when neither the raw response nor the original exception have a backtrace' do
+      it 'returns an empty array' do
+        raw = Grape::Exceptions::ErrorResponse.new
+        expect(middleware.__send__(:resolved_backtrace, raw)).to eq([])
+      end
+    end
+  end
+
+  describe '#grape_exceptions_precedence_handler' do
+    subject(:middleware) { described_class.new(->(_env) {}, rescue_grape_exceptions: true) }
+
+    it 'leaves InvalidVersionHeader alone so it keeps reaching Rack' do
+      handler = middleware.__send__(:grape_exceptions_precedence_handler, Grape::Exceptions::InvalidVersionHeader, nil)
+      expect(handler).to be_nil
+    end
+  end
 end

spec/grape/middleware/stack_spec.rb

@@ -18,7 +18,7 @@ def initialize(&block)
   let(:others) { [[:use, bar_middleware], [:insert_before, bar_middleware, block_middleware, proc]] }
 
   before do
-    subject.use foo_middleware
+    subject.use foo_middleware if subject.respond_to?(:use)
   end
 
   describe '#use' do
@@ -151,4 +151,14 @@ def initialize(&block)
       subject.concat others
     end
   end
+
+  describe Grape::Middleware::Stack::Middleware do
+    subject { described_class.new(foo_middleware, [], nil) }
+
+    describe '#==' do
+      it 'returns falsy for an object that is neither a Middleware nor a Class' do
+        expect(subject == 'not a middleware').to be_falsy
+      end
+    end
+  end
 end

spec/grape/middleware/versioner/header_spec.rb

@@ -338,4 +338,13 @@ def app
       expect { versioned_get '/', 'v1', using: :header }.to raise_error Grape::Exceptions::MissingVendorOption
     end
   end
+
+  context 'when the vendor option is not set on the middleware directly' do
+    subject { described_class.new(app, version_options: Grape::DSL::VersionOptions.new(using: :header, vendor: nil)) }
+
+    it 'skips the best-quality-media-type match entirely' do
+      status, = subject.call('HTTP_ACCEPT' => 'application/vnd.vendor+json')
+      expect(status).to eq(200)
+    end
+  end
 end

spec/grape/namespace_spec.rb

@@ -30,4 +30,15 @@
       expect(namespace.hash).not_to eq(other.hash)
     end
   end
+
+  describe '.joined_space' do
+    it 'maps a list of Namespace objects to their #space' do
+      other = described_class.new('bar')
+      expect(described_class.joined_space([namespace, other])).to eq(%w[foo bar])
+    end
+
+    it 'returns nil for a nil settings list' do
+      expect(described_class.joined_space(nil)).to be_nil
+    end
+  end
 end

spec/grape/router/base_route_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+describe Grape::Router::BaseRoute do
+  let(:pattern) { instance_double(Grape::Router::Pattern) }
+
+  describe '#initialize' do
+    context 'when options is a plain Hash' do
+      subject(:route) { described_class.new(pattern, { foo: 'bar' }) }
+
+      it 'wraps it in an ActiveSupport::OrderedOptions' do
+        expect(route.options).to be_a(ActiveSupport::OrderedOptions)
+      end
+
+      it 'reads back the given options' do
+        expect(route.options[:foo]).to eq('bar')
+      end
+    end
+
+    context 'when options is already an ActiveSupport::OrderedOptions' do
+      subject(:route) { described_class.new(pattern, options) }
+
+      let(:options) { ActiveSupport::OrderedOptions.new.update(foo: 'bar') }
+
+      it 'uses it as-is, without wrapping it again' do
+        expect(route.options).to equal(options)
+      end
+    end
+  end
+end