joblin 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b97d9567bb5853da62d6dc2dd5fb8be9c4542b8edce5ac3c8c04a41911cba4c
-  data.tar.gz: fe8836c6aa2f974d1647f4d5c80b3d4f6c7913a1ac5750fa06ba6d8901b825e7
+  metadata.gz: 988601efd5b12dd1866c4dd0e6adbe223fd33421929e3bf78ad0ee799a3e6e53
+  data.tar.gz: 850bc134faba3424e2bbbce58c7d3daefa4d37d8d76f55c92a7602242f46565a
 SHA512:
-  metadata.gz: a5a5b430bf022fd87de5bc8cf045f14b8621dcc6f198ba5cbd2c08144e7d15e664a18e4afb3e09160014b0ab0cd70e799681744c4c9937295ea96890cc5e4367
-  data.tar.gz: 06d5967211f519e0ab1875b63424e946147d3bcd395c499516d784e306f2fedd32ad9d99ca58a1bfcf3343c920473dfd86f6a69c6a5dc297e66486f4d019f2ce
+  metadata.gz: 727eac8e2f058579bf1f109b0f3faa5658e166c895ec37be6a12c9052c8982a8b6ba46debbc3fff8b780cd4af5a92d28c87164bf26baa3850df2297917db2085
+  data.tar.gz: a9c4b246ca613eeb98fc464f3e333a6ff9135fe14c51e4b8fe949d87fe2789da4cc4909d86f77362696b343b252d3bac246a88902df18dd86fc933dcdac16a51

data/lib/joblin/batching/compat/sidekiq/web.rb

@@ -10,41 +10,143 @@ require_relative "web/helpers"
 module Joblin::Batching::Compat::Sidekiq
   module Web
     DEV_MODE = (defined?(Rails) && !Rails.env.production?) || !!ENV["SIDEKIQ_WEB_TESTING"]
-    ::Sidekiq::WebHelpers::SAFE_QPARAMS << 'all_batches'
-    ::Sidekiq::WebHelpers::SAFE_QPARAMS << 'count'
 
-    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      app.helpers do
-        include Web::Helpers
+    if defined?(::Sidekiq::WebHelpers::SAFE_QPARAMS)
+      ::Sidekiq::WebHelpers::SAFE_QPARAMS << 'all_batches' unless ::Sidekiq::WebHelpers::SAFE_QPARAMS.include?('all_batches')
+      ::Sidekiq::WebHelpers::SAFE_QPARAMS << 'count' unless ::Sidekiq::WebHelpers::SAFE_QPARAMS.include?('count')
+    end
+
+    # Helpers shared with the route blocks. We expose these via a module so the
+    # same registration code works on both Sidekiq 7 (which accepts a block) and
+    # Sidekiq 8 (whose `Application.helpers` only accepts a module).
+    module RouteHelpers
+      include Web::Helpers
+
+      def dev_mode?
+        DEV_MODE
+      end
+
+      # Read a route (path) parameter such as `:bid` from `/batches/:bid`.
+      #
+      # We cannot rely on `params[:bid]` across majors: Sidekiq 7's `params` is
+      # an indifferent hash that includes route params, but Sidekiq 8's `params`
+      # returns only the query string (String keys), so `params[:bid]` would be
+      # nil there. Sidekiq 8 exposes route params via `route_params(:bid)`. We
+      # read straight from the Rack env, which the router populates under this
+      # key on both Sidekiq 7 (WebRouter::ROUTE_PARAMS) and Sidekiq 8, so the
+      # same call works regardless of version and avoids deprecation warnings.
+      def route_param(key)
+        (env["rack.route_params"] || {})[key.to_sym]
+      end
+
+      # Read a query-string parameter such as `count` or `page`.
+      #
+      # Sidekiq 7+ defines `url_params(key)` on the web action and returns the
+      # query value only. Sidekiq 6.x has no `url_params`; there the action's
+      # `params` is an indifferent hash that already merges the query string,
+      # so we read from it. On Sidekiq 7/8 the action's own `url_params`
+      # shadows this fallback (a class's instance method wins over one from an
+      # included module), so this definition only takes effect on Sidekiq 6.x.
+      def url_params(key)
+        params[key]
+      end
+
+      def tree_data(root_bid, slice: nil)
+        tree_bids = Joblin::Batching::Batch.bid_hierarchy(root_bid, slice: slice)
+
+        Joblin::Batching::Batch.redis do |r|
+          layer_data = ->(layer, parent = nil) {
+            bid = layer[0]
+            batch = Joblin::Batching::Batch.new(bid)
+
+            jobs_total = r.hget("BID-#{bid}", "job_count").to_i
+            jobs_pending = r.hget("BID-#{bid}", 'pending').to_i
+            jobs_failed = r.scard("BID-#{bid}-failed").to_i
+            jobs_dead = r.scard("BID-#{bid}-dead").to_i
+            jobs_success = jobs_total - jobs_pending
+
+            batches_total = r.hget("BID-#{bid}", 'children').to_i
+            batches_success = r.scard("BID-#{bid}-batches-success").to_i
+            batches_pending = batches_total - batches_success
+            batches_failed = r.scard("BID-#{bid}-batches-failed").to_i
+
+            status = 'in_progress'
+            status = 'complete' if batches_pending == batches_failed && jobs_pending == jobs_failed
+            status = 'success' if batches_pending == 0 && jobs_pending == 0
+            status = 'deleted' if bid != root_bid && !batch.parent_bid
+
+            {
+              bid: bid,
+              created_at: r.hget("BID-#{bid}", 'created_at'),
+              status: status,
+              parent_bid: parent ? parent.bid : batch.parent_bid,
+              description: batch.description,
+              jobs: {
+                pending_count: jobs_pending,
+                successful_count: jobs_success,
+                failed_count: jobs_failed,
+                dead_count: jobs_dead,
+                total_count: jobs_total,
+                # items: batches.map{|b| layer_data[b] },
+              },
+              batches: {
+                pending_count: batches_pending,
+                successful_count: batches_success,
+                failed_count: batches_failed,
+                total_count: batches_total,
+                items: layer[1].map{|b| layer_data[b, batch] },
+              },
+            }
+          }
+
+          data = layer_data[tree_bids]
+          data[:batches][:slice] = slice if slice
+          data
+        end
+      end
 
-        def dev_mode?
-          DEV_MODE
+      def format_context(batch)
+        bits = []
+        own_keys = batch.context.own.keys
+        batch.context.flatten.each do |k,v|
+          added = own_keys.include? k
+          bits << "  <span class=\"key #{added ? 'own' : 'inherited'}\">\"#{k}\": #{v.to_json},</span>"
         end
+        bits = [
+          "{ // <span class=\"own\">Added</span> / <span class=\"inherited\">Inherited</span>",
+          *bits,
+          '}'
+        ]
+        bits.join("\n")
       end
+    end
+
+    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      app.helpers(RouteHelpers)
 
       # =============== BATCHES =============== #
 
       app.get "/batches" do
-        @count = (params['count'] || 25).to_i
+        @count = (url_params('count') || 25).to_i
 
-        source_key = params['all_batches'] ? "batches" : "BID-ROOT-bids"
-        @current_page, @total_size, @batches = page(source_key, params['page'], @count)
+        source_key = url_params('all_batches') ? "batches" : "BID-ROOT-bids"
+        @current_page, @total_size, @batches = page(source_key, url_params('page'), @count)
         @batches = @batches.map {|b, score| Joblin::Batching::Batch.new(b) }
 
         erb(get_template(:batches))
       end
 
       app.get "/batches/:bid" do
-        @bid = params[:bid]
+        @bid = route_param(:bid)
         @batch = Joblin::Batching::Batch.new(@bid)
 
         @tree_data = tree_data(@bid)
 
-        @count = (params['count'] || 25).to_i
-        @current_batches_page, @total_batches_size, @sub_batches = page("BID-#{@batch.bid}-bids", params['batch_page'], @count)
+        @count = (url_params('count') || 25).to_i
+        @current_batches_page, @total_batches_size, @sub_batches = page("BID-#{@batch.bid}-bids", url_params('batch_page'), @count)
         @sub_batches = @sub_batches.map {|b, score| Joblin::Batching::Batch.new(b) }
 
-        @current_jobs_page, @total_jobs_size, @jobs = page("BID-#{@batch.bid}-jids", params['job_page'], @count)
+        @current_jobs_page, @total_jobs_size, @jobs = page("BID-#{@batch.bid}-jids", url_params('job_page'), @count)
         @jobs = @jobs.map do |jid, score|
           { jid: jid, }
         end
@@ -53,84 +155,13 @@ module Joblin::Batching::Compat::Sidekiq
       end
 
       app.get "/batches/:bid/tree" do
-        @bid = params[:bid]
-
-        json(tree_data(@bid, slice: params[:slice]))
-      end
-
-      app.helpers do
-        def tree_data(root_bid, slice: nil)
-          tree_bids = Joblin::Batching::Batch.bid_hierarchy(root_bid, slice: slice)
-
-          Joblin::Batching::Batch.redis do |r|
-            layer_data = ->(layer, parent = nil) {
-              bid = layer[0]
-              batch = Joblin::Batching::Batch.new(bid)
-
-              jobs_total = r.hget("BID-#{bid}", "job_count").to_i
-              jobs_pending = r.hget("BID-#{bid}", 'pending').to_i
-              jobs_failed = r.scard("BID-#{bid}-failed").to_i
-              jobs_dead = r.scard("BID-#{bid}-dead").to_i
-              jobs_success = jobs_total - jobs_pending
-
-              batches_total = r.hget("BID-#{bid}", 'children').to_i
-              batches_success = r.scard("BID-#{bid}-batches-success").to_i
-              batches_pending = batches_total - batches_success
-              batches_failed = r.scard("BID-#{bid}-batches-failed").to_i
-
-              status = 'in_progress'
-              status = 'complete' if batches_pending == batches_failed && jobs_pending == jobs_failed
-              status = 'success' if batches_pending == 0 && jobs_pending == 0
-              status = 'deleted' if bid != root_bid && !batch.parent_bid
-
-              {
-                bid: bid,
-                created_at: r.hget("BID-#{bid}", 'created_at'),
-                status: status,
-                parent_bid: parent ? parent.bid : batch.parent_bid,
-                description: batch.description,
-                jobs: {
-                  pending_count: jobs_pending,
-                  successful_count: jobs_success,
-                  failed_count: jobs_failed,
-                  dead_count: jobs_dead,
-                  total_count: jobs_total,
-                  # items: batches.map{|b| layer_data[b] },
-                },
-                batches: {
-                  pending_count: batches_pending,
-                  successful_count: batches_success,
-                  failed_count: batches_failed,
-                  total_count: batches_total,
-                  items: layer[1].map{|b| layer_data[b, batch] },
-                },
-              }
-            }
-
-            data = layer_data[tree_bids]
-            data[:batches][:slice] = slice if slice
-            data
-          end
-        end
+        @bid = route_param(:bid)
 
-        def format_context(batch)
-          bits = []
-          own_keys = batch.context.own.keys
-          batch.context.flatten.each do |k,v|
-            added = own_keys.include? k
-            bits << "  <span class=\"key #{added ? 'own' : 'inherited'}\">\"#{k}\": #{v.to_json},</span>"
-          end
-          bits = [
-            "{ // <span class=\"own\">Added</span> / <span class=\"inherited\">Inherited</span>",
-            *bits,
-            '}'
-          ]
-          bits.join("\n")
-        end
+        json(tree_data(@bid, slice: url_params('slice')))
       end
 
       app.post "/batches/all" do
-        if params['delete']
+        if url_params('delete')
           index_key = Joblin::Batching::Batch::INDEX_ALL_BATCHES ? "batches" : "BID-ROOT-bids"
           drain_zset(index_key) do |batches|
             batches.each do |bid|
@@ -143,10 +174,10 @@ module Joblin::Batching::Compat::Sidekiq
       end
 
       app.post "/batches/:bid" do
-        @bid = params[:bid]
+        @bid = route_param(:bid)
         @batch = Joblin::Batching::Batch.new(@bid)
 
-        if params['delete']
+        if url_params('delete')
           Joblin::Batching::Batch.delete_prematurely!(@bid)
         end
 
@@ -156,28 +187,28 @@ module Joblin::Batching::Compat::Sidekiq
       # =============== POOLS =============== #
 
       app.get "/pools" do
-        @count = (params['count'] || 25).to_i
-        @current_page, @total_size, @pools = page('pools', params['page'], @count)
+        @count = (url_params('count') || 25).to_i
+        @current_page, @total_size, @pools = page('pools', url_params('page'), @count)
         @pools = @pools.map {|b, score| Joblin::Batching::Pool.new(b) }
 
         erb(get_template(:pools))
       end
 
       app.get "/pools/:pid" do
-        @pid = params[:pid]
+        @pid = route_param(:pid)
         @pool = Joblin::Batching::Pool.new(@pid)
 
         @active_tasks = @pool.active_jobs
 
-        @count = (params['count'] || 25).to_i
-        @current_jobs_page, @total_jobs_size, @jobs = page("POOLID-#{@pool.pid}-jobs", params['job_page'], @count)
+        @count = (url_params('count') || 25).to_i
+        @current_jobs_page, @total_jobs_size, @jobs = page("POOLID-#{@pool.pid}-jobs", url_params('job_page'), @count)
         @jobs = @jobs.map {|desc, score=nil| JSON.parse(desc)[0] }
 
         erb(get_template(:pool))
       end
 
       app.post "/pools/all" do
-        if params['delete']
+        if url_params('delete')
           drain_zset('pools') do |pools|
             pools.each do |pid|
               Joblin::Batching::Pool.from_pid(pid).cleanup_redis
@@ -189,16 +220,56 @@ module Joblin::Batching::Compat::Sidekiq
       end
 
       app.post "/pools/:pid" do
-        @pid = params[:pid]
+        @pid = route_param(:pid)
         @pool = Joblin::Batching::Pool.from_pid(@pid)
 
-        if params['delete']
+        if url_params('delete')
           @pool.cleanup_redis
         end
 
         redirect_with_query("#{root_path}pools")
       end
     end
+
+    # Register this extension's Batches + Pools tabs against `web_class`,
+    # choosing the call shape that matches the installed Sidekiq.
+    #
+    # The `Sidekiq::Web.register` API changed twice across the supported range,
+    # so we capability-detect rather than parse version strings:
+    #
+    # * Sidekiq 7.3.9+ and 8.x expose `Sidekiq::Web.configure`. The Sidekiq 8
+    #   `register` emits a deprecation warning unless called through the
+    #   `configure` block, so we use that. The keyword `register` registers the
+    #   tabs itself via the tab/index zip, so we do not also set `tabs[...]`.
+    # * Sidekiq 7.3.0-7.3.8 have the keyword `register` but no `configure`. We
+    #   call `register(ext, name:, tab:, index:)` directly; it too registers the
+    #   tabs from the zip.
+    # * Sidekiq <= 7.2.x only have the single-argument `register(extension)`,
+    #   which just calls `extension.registered(app)` and never touches `tabs`.
+    #   There we fall back to the original behavior: register, then set the tabs
+    #   manually.
+    #
+    # Detect the keyword form by inspecting `register`'s parameters for the
+    # `name:` keyword instead of relying on a Sidekiq version constant.
+    def self.register_tabs(web_class) # rubocop:disable Metrics/MethodLength
+      register_args = {
+        name: "joblin_batches",
+        tab: ["Batches", "Pools"],
+        index: ["batches", "pools"]
+      }
+
+      if web_class.respond_to?(:configure)
+        web_class.configure do |cfg|
+          cfg.register(self, **register_args)
+        end
+      elsif web_class.method(:register).parameters.any? { |type, name| name == :name && (type == :key || type == :keyreq) }
+        web_class.register(self, **register_args)
+      else
+        web_class.register(self)
+        web_class.tabs["Batches"] = "batches"
+        web_class.tabs["Pools"] = "pools"
+      end
+    end
   end
 end
 
@@ -206,13 +277,23 @@ if defined?(::Sidekiq::Web)
   rules = []
   rules = [[:all, {"Cache-Control" => "public, max-age=86400"}]] unless Joblin::Batching::Compat::Sidekiq::Web::DEV_MODE
 
+  # Serve the bundled JS/CSS at /batches_assets. The erb views reference these
+  # URLs directly, so we keep this manual mount rather than Sidekiq 8's
+  # name-namespaced asset convention (which would change the URLs).
   ::Sidekiq::Web.use Rack::Static, urls: ["/batches_assets"],
                                    root: File.expand_path("#{File.dirname(__FILE__)}/web"),
                                    cascade: true,
                                    header_rules: rules
 
-  ::Sidekiq::Web.register Joblin::Batching::Compat::Sidekiq::Web
-  ::Sidekiq::Web.tabs["Batches"] = "batches"
-  ::Sidekiq::Web.tabs["Pools"] = "pools"
-  ::Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "locales")
+  Joblin::Batching::Compat::Sidekiq::Web.register_tabs(::Sidekiq::Web)
+
+  # The original code appended a `locales` directory that does not exist in this
+  # gem; preserve that harmless behavior without crashing if `settings` is gone
+  # (Sidekiq 8 removed `Sidekiq::Web.settings`; `locales` is available on both).
+  locales_dir = File.join(File.dirname(__FILE__), "locales")
+  if ::Sidekiq::Web.respond_to?(:locales)
+    ::Sidekiq::Web.locales << locales_dir
+  elsif ::Sidekiq::Web.respond_to?(:settings)
+    ::Sidekiq::Web.settings.locales << locales_dir
+  end
 end

data/lib/joblin/batching/compat/sidekiq.rb

@@ -81,10 +81,21 @@ module Joblin::Batching
         end
       end
 
+      # Sidekiq 8 renamed the ActiveJob wrapper class. Accept both so
+      # ActiveJob-based jobs stay batch-aware across Sidekiq 7 and 8.
+      ACTIVE_JOB_WRAPPERS = [
+        'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper',
+        'Sidekiq::ActiveJob::Wrapper',
+      ].freeze
+
       def self.is_activejob_job?(msg)
         return false unless defined?(::ActiveJob)
+        return false unless ACTIVE_JOB_WRAPPERS.include?(msg['class'])
 
-        msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && (msg['wrapped'].to_s).constantize < Joblin::Batching::Compat::ActiveJob::BatchAwareJob
+        # `wrapped` comes from the job payload; use safe_constantize so a
+        # malformed/unknown value yields nil rather than raising NameError.
+        wrapped = msg['wrapped'].to_s.safe_constantize
+        !!(wrapped && wrapped < Joblin::Batching::Compat::ActiveJob::BatchAwareJob)
       end
 
       def self.switch_tenant(job)

data/lib/joblin/uniqueness/compat/sidekiq.rb

@@ -73,10 +73,21 @@ module Joblin::Uniqueness
         end
       end
 
+      # Sidekiq 8 renamed the ActiveJob wrapper class. Accept both so
+      # ActiveJob-based jobs keep their unique-job handling across Sidekiq 7 and 8.
+      ACTIVE_JOB_WRAPPERS = [
+        'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper',
+        'Sidekiq::ActiveJob::Wrapper',
+      ].freeze
+
       def self.is_activejob_job?(msg)
         return false unless defined?(::ActiveJob)
+        return false unless ACTIVE_JOB_WRAPPERS.include?(msg['class'])
 
-        msg['class'] == 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper' && (msg['wrapped'].to_s).constantize < Compat::ActiveJob::UniqueJobExtension
+        # `wrapped` comes from the job payload; use safe_constantize so a
+        # malformed/unknown value yields nil rather than raising NameError.
+        wrapped = msg['wrapped'].to_s.safe_constantize
+        !!(wrapped && wrapped < Compat::ActiveJob::UniqueJobExtension)
       end
 
       def self.validate_middleware_order(chain, order)

data/lib/joblin/version.rb

@@ -1,3 +1,3 @@
 module Joblin
-  VERSION = "0.1.10".freeze
+  VERSION = "0.1.12".freeze
 end

data/spec/batching/compat/sidekiq_spec.rb

@@ -111,6 +111,36 @@ RSpec.describe Joblin::Batching::Compat::Sidekiq do
     end
   end
 
+  describe '.is_activejob_job?' do
+    let(:wrapped_class) do
+      Class.new(ActiveJob::Base) do
+        include Joblin::Batching::Compat::ActiveJob::BatchAwareJob
+      end
+    end
+
+    before { stub_const('WrappedBatchAwareJob', wrapped_class) }
+
+    it 'returns true for the legacy Sidekiq 7 wrapper class' do
+      msg = { 'class' => 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper', 'wrapped' => 'WrappedBatchAwareJob' }
+      expect(Joblin::Batching::Compat::Sidekiq.is_activejob_job?(msg)).to be_truthy
+    end
+
+    it 'returns true for the Sidekiq 8 wrapper class' do
+      msg = { 'class' => 'Sidekiq::ActiveJob::Wrapper', 'wrapped' => 'WrappedBatchAwareJob' }
+      expect(Joblin::Batching::Compat::Sidekiq.is_activejob_job?(msg)).to be_truthy
+    end
+
+    it 'returns false for a plain (non-ActiveJob) job' do
+      msg = { 'class' => 'SomePlainWorker' }
+      expect(Joblin::Batching::Compat::Sidekiq.is_activejob_job?(msg)).to be_falsey
+    end
+
+    it 'returns false without raising for a wrapper whose wrapped class is unknown' do
+      msg = { 'class' => 'Sidekiq::ActiveJob::Wrapper', 'wrapped' => 'No::Such::Constant' }
+      expect(Joblin::Batching::Compat::Sidekiq.is_activejob_job?(msg)).to be_falsey
+    end
+  end
+
   context 'worker' do
     it 'defines method bid' do
       expect(Sidekiq::Worker.instance_methods).to include(:bid)

data/spec/batching/compat/sidekiq_web_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+# Sidekiq's Web UI isn't loadable in every supported environment: Sidekiq 6
+# pulls in `rack/file`, which Rack 3 removed, so `require "sidekiq/web"` raises
+# LoadError there. joblin's own web compat guards the same require, so skip
+# these specs rather than fail when Web can't load. A non-LoadError (e.g. the
+# registration regression this file exists to catch) still propagates.
+begin
+  require 'sidekiq/web'
+  require 'joblin/batching/compat/sidekiq/web'
+rescue LoadError
+  return
+end
+
+# Regression coverage for https://github.com/.../joblin web compat.
+#
+# joblin's web extension used to call `Sidekiq::Web.register(extension)` with a
+# single positional argument and `Sidekiq::Web.settings.locales << ...`. Both of
+# those crash on Sidekiq 8: `register` now requires the `name:`/`tab:`/`index:`
+# keywords, and `Sidekiq::Web.settings` was removed. These specs assert that
+# loading the compat file registers the Batches and Pools tabs without raising
+# on whichever Sidekiq major is installed, so the bug cannot silently return.
+RSpec.describe Joblin::Batching::Compat::Sidekiq::Web do
+  describe 'tab registration' do
+    it 'registers a Batches tab pointing at the batches index' do
+      expect(::Sidekiq::Web.tabs['Batches']).to eq('batches')
+    end
+
+    it 'registers a Pools tab pointing at the pools index' do
+      expect(::Sidekiq::Web.tabs['Pools']).to eq('pools')
+    end
+  end
+
+  describe '.register_tabs (capability branch selection)' do
+    # The bundled Sidekiq is 7.3.9, so only the `configure` branch runs against
+    # the real gem. These doubles exercise all three branches regardless of the
+    # installed major, so an older-Sidekiq regression cannot slip through.
+    #
+    # The single-arg `register(extension)` double calls `registered` on the real
+    # extension, so we register against the same fake-app collaborator the
+    # `.registered` examples use to keep the route bodies from blowing up.
+    let(:fake_app) do
+      Class.new do
+        attr_reader :routes, :helper_modules
+
+        def initialize
+          @routes = []
+          @helper_modules = []
+        end
+
+        def helpers(mod = nil, &block)
+          @helper_modules << (mod || block)
+        end
+
+        def get(path, &block)
+          @routes << [:get, path, block]
+        end
+
+        def post(path, &block)
+          @routes << [:post, path, block]
+        end
+      end
+    end
+
+    it 'uses configure when the web class is configure-capable (Sidekiq 7.3.9+/8.x)' do
+      tabs = {}
+      registered_with = nil
+      cfg = Object.new
+      cfg.define_singleton_method(:register) do |ext, name:, tab:, index:|
+        registered_with = { ext: ext, name: name }
+        tab.zip(index).each { |t, i| tabs[t] = i }
+      end
+
+      web_class = Object.new
+      web_class.define_singleton_method(:configure) { |&blk| blk.call(cfg) }
+      # configure-capable classes also respond to :register, but the branch must
+      # prefer configure to avoid the Sidekiq 8 deprecation warning.
+      web_class.define_singleton_method(:register) { |*, **| raise 'should not call register directly' }
+
+      expect { described_class.register_tabs(web_class) }.not_to raise_error
+      expect(registered_with[:ext]).to eq(described_class)
+      expect(tabs).to eq('Batches' => 'batches', 'Pools' => 'pools')
+    end
+
+    it 'calls keyword register directly when configure is absent (Sidekiq 7.3.0-7.3.8)' do
+      tabs = {}
+      web_class = Object.new
+      web_class.define_singleton_method(:register) do |ext, name: nil, tab: nil, index: nil|
+        Array(tab).zip(Array(index)).each { |t, i| tabs[t] = i }
+      end
+
+      expect { described_class.register_tabs(web_class) }.not_to raise_error
+      expect(tabs).to eq('Batches' => 'batches', 'Pools' => 'pools')
+    end
+
+    it 'falls back to single-arg register plus manual tabs (Sidekiq <= 7.2.x)' do
+      app = fake_app.new
+      tabs = {}
+      web_class = Object.new
+      web_class.define_singleton_method(:tabs) { tabs }
+      # Single-arg register mirrors real Sidekiq 7.2: it just calls back into the
+      # extension's `registered` and never touches tabs.
+      web_class.define_singleton_method(:register) do |ext|
+        ext.registered(app)
+      end
+
+      expect { described_class.register_tabs(web_class) }.not_to raise_error
+      expect(tabs).to eq('Batches' => 'batches', 'Pools' => 'pools')
+      paths = app.routes.map { |(_method, path, _block)| path }
+      expect(paths).to include('/batches', '/pools')
+    end
+  end
+
+  describe '.registered' do
+    # `register` ran once at load time above; re-running against a fresh fake
+    # application proves the registration path itself does not raise on the
+    # installed Sidekiq major. This is the path that crashed on Sidekiq 8.
+    let(:fake_app) do
+      Class.new do
+        # Capture the routes/helpers the extension tries to install so the call
+        # exercises the real `registered` body without needing a live Rack app.
+        attr_reader :routes, :helper_modules
+
+        def initialize
+          @routes = []
+          @helper_modules = []
+        end
+
+        def helpers(mod = nil, &block)
+          @helper_modules << (mod || block)
+        end
+
+        def get(path, &block)
+          @routes << [:get, path, block]
+        end
+
+        def post(path, &block)
+          @routes << [:post, path, block]
+        end
+      end.new
+    end
+
+    it 'installs the batches and pools routes without raising' do
+      expect { described_class.registered(fake_app) }.not_to raise_error
+
+      paths = fake_app.routes.map { |(_method, path, _block)| path }
+      expect(paths).to include('/batches', '/batches/:bid', '/pools', '/pools/:pid')
+    end
+
+    it 'installs helpers as a module (Sidekiq 8 only accepts modules)' do
+      described_class.registered(fake_app)
+
+      expect(fake_app.helper_modules).to all(be_a(Module))
+      expect(fake_app.helper_modules).to include(Joblin::Batching::Compat::Sidekiq::Web::RouteHelpers)
+    end
+  end
+
+  describe Joblin::Batching::Compat::Sidekiq::Web::RouteHelpers do
+    # `route_param` is the cross-version shim for path params such as `:bid`.
+    # On Sidekiq 7 `params[:bid]` worked; on Sidekiq 8 it does not, so we read
+    # the Rack env directly. Verify it pulls the value regardless of key type.
+    let(:helper_host) do
+      Class.new do
+        include Joblin::Batching::Compat::Sidekiq::Web::RouteHelpers
+
+        attr_accessor :env
+
+        def initialize(env)
+          @env = env
+        end
+      end
+    end
+
+    it 'reads route params from the Rack env' do
+      host = helper_host.new('rack.route_params' => { bid: 'ABC123' })
+      expect(host.route_param(:bid)).to eq('ABC123')
+      expect(host.route_param('bid')).to eq('ABC123')
+    end
+
+    it 'returns nil when no route params are present' do
+      host = helper_host.new({})
+      expect(host.route_param(:bid)).to be_nil
+    end
+  end
+end