inferno_core 1.4.5 → 1.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cffc2d9b151af63840789863f04e8551fd82077351f85d356b5a88f103f28f2
-  data.tar.gz: c6687758255cf5acadb700dfd268ee65f6ab03713dbc17ec412d1240d7f352b7
+  metadata.gz: 0ed690c6df4e1cfcb7f4ec361fb8326af28107839c20fbb9de6069ccdc3e950b
+  data.tar.gz: 1c35c4afdf97fc1f8e053d213bdc643099c79defd0b09e50fccb34977a2a497d
 SHA512:
-  metadata.gz: 0f7ca455177f14a4f0ad5dae5852a7b7441e7ef867e554678b8d55410d623cb7b1d0e4e4432dbd8f1c8cdc085943801d2b98601d9ea776cd1e93f6482a02e3b9
-  data.tar.gz: d4160ba11c06d24fc185c2b4cde86fc36c519499f383c79053246114b2e69d0e5be4504e87ea476f462e1439383f8c1a07a5efcab2701449cbd6458939faa13b
+  metadata.gz: '048ca08826b17e50cbbd7452d600e996287167ec72d7993ed3a7686849bc6bbcd61221138df2dd5520ee9156deda55c8d577d99f9ade542d17cda31857d82837'
+  data.tar.gz: b1878c6aedf0f99732536a02fad0cbc2cf2913d21e8cae56586764a04c428346303fd9fb95c462538a96a3968fee7cac3cb0e27bd8b28998e293597aa94d7fd9

data/lib/inferno/apps/web/router.rb

@@ -98,7 +98,7 @@ module Inferno
       Inferno.routes.each do |route|
         cleaned_id = route[:suite].id.gsub(/[^a-zA-Z\d\-._~]/, '_')
         path = "/custom/#{cleaned_id}#{route[:path]}"
-        Application['logger'].info("Registering custom route: #{path}")
+        Application['logger'].info("Registering custom route: #{route[:method].to_s.upcase} #{path}")
         if route[:method] == :all
           mount route[:handler], at: path
         else

data/lib/inferno/config/boot/db.rb

@@ -16,11 +16,6 @@ module Inferno
         # or writes from another. WAL mode lets readers proceed without blocking on a
         # concurrent writer, and a longer busy_timeout gives a blocked writer more
         # room to wait its turn instead of immediately raising SQLITE_BUSY.
-        #
-        # If you change this, run `bundle exec rake db:check_concurrency` to verify
-        # SQLITE_BUSY is still avoided under concurrent test-run writes and status
-        # polling (see lib/inferno/utils/db_concurrency_check.rb for why that's a
-        # rake task and not a spec).
         def configure_sqlite_pragmas!(config)
           return config unless config['adapter'] == 'sqlite'
 

data/lib/inferno/dsl/must_support_assessment.rb

@@ -141,7 +141,9 @@ module Inferno
 
         def handle_must_support_slice_choices
           missing_slices.delete_if do |slice|
-            choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
+            choices = metadata.must_supports[:choices].find do |choice|
+              choice[:slice_names]&.any? { |slice_name| slice_identified_by?(slice, slice_name) }
+            end
             any_choice_supported?(choices)
           end
         end
@@ -172,7 +174,15 @@ module Inferno
         def any_slice_names_choice_supported?(choices)
           return false unless choices[:slice_names].present?
 
-          choices[:slice_names].any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name } }
+          choices[:slice_names].any? do |slice_name|
+            missing_slices.none? { |slice| slice_identified_by?(slice, slice_name) }
+          end
+        end
+
+        # Entries in a choice's slice_names may be either the slice name (eg 'us-core') or the slice id
+        # (eg 'Condition.category:us-core'). The id is unique within a profile while the name may not be.
+        def slice_identified_by?(slice, slice_name_or_id)
+          [slice[:slice_name], slice[:slice_id]].include?(slice_name_or_id)
         end
 
         def any_elements_choice_supported?(choices)
@@ -303,28 +313,6 @@ module Inferno
           ]
         end
 
-        def process_must_support_element_in_extension(resource, path)
-          return [resource, path] unless path.start_with?('extension:')
-
-          path_without_prefix = path.delete_prefix('extension:')
-          extension_split = path_without_prefix.split('.')
-          extension_name = extension_split.first
-          extension_path = extension_split.last
-
-          found_extension_url =
-            normalized_extension_url(must_support_extensions.find { |ex| ex[:id].include?(extension_name) }[:url])
-          ms_element_extension = resource.extension.find do |extension|
-            normalized_extension_url(extension.url) == found_extension_url
-          end
-
-          if ms_element_extension.present?
-            resource = ms_element_extension
-            path = extension_path
-          end
-
-          [resource, path]
-        end
-
         def matching_without_extensions?(value, ms_extension_urls, fixed_value)
           has_ms_extension = must_support_extension_present?(value, ms_extension_urls)
 

data/lib/inferno/entities/test_kit.rb

@@ -168,9 +168,11 @@ module Inferno
         end
 
         # @private
-        def copy_instance_variables
+        def copy_instance_variables(subclass)
+          # The id must be unique, and the suites and options are memoized from
+          # suite_ids, which the subclass may change.
           instance_variables
-            .reject { |variable| [:id].include? variable }
+            .reject { |variable| [:@id, :@suites, :@options].include? variable }
             .each { |variable| subclass.instance_variable_set(variable, instance_variable_get(variable).dup) }
         end
       end

data/lib/inferno/jobs/execute_test_run.rb

@@ -3,6 +3,9 @@ module Inferno
     class ExecuteTestRun
       include Sidekiq::Worker
 
+      # Retrying would replay the whole test run, so surface failures instead.
+      sidekiq_options retry: false
+
       def perform(test_run_id)
         test_run = Inferno::Repositories::TestRuns.new.find(test_run_id)
         test_session = Inferno::Repositories::TestSessions.new.find(test_run.test_session_id)

data/lib/inferno/jobs/resume_test_run.rb

@@ -3,6 +3,10 @@ module Inferno
     class ResumeTestRun
       include Sidekiq::Worker
 
+      # Retrying would rerun the test that was in progress, resending its
+      # requests, so surface failures instead.
+      sidekiq_options retry: false
+
       def perform(test_run_id)
         test_run = Inferno::Repositories::TestRuns.new.find(test_run_id)
         test_session = Inferno::Repositories::TestSessions.new.find(test_run.test_session_id)

data/lib/inferno/test_runner.rb

@@ -89,8 +89,12 @@ module Inferno
           if result == 'wait'
             # The waiting status and the wait result must become visible to
             # readers atomically, so that pollers never see the run waiting
-            # without the waiting test's result being present.
-            Inferno::Application['db.connection'].transaction do
+            # without the waiting test's result being present. Immediate mode
+            # takes the sqlite write lock up front () mark_as_waiting reads before
+            # it writes) and is used to avoid a SQLITE_BUSY error without waiting
+            # out busy_timeout when it tries to upgrade to a write lock that is
+            # already taken.
+            Inferno::Application['db.connection'].transaction(mode: :immediate) do
               test_runs_repo.mark_as_waiting(test_run.id, test_instance.identifier, test_instance.wait_timeout)
               persist_result(result_params)
             end
@@ -280,11 +284,10 @@ module Inferno
       # into a single lock acquisition instead of one per insert, cutting
       # down on sqlite write-lock contention with concurrent readers/writers.
       #
-      # If you change this, run `bundle exec rake db:check_concurrency` to verify
-      # SQLITE_BUSY is still avoided under concurrent test-run writes and status
-      # polling (see lib/inferno/utils/db_concurrency_check.rb for why that's a
-      # rake task and not a spec).
-      result = Inferno::Application['db.connection'].transaction do
+      # Immediate mode takes the write lock up front so that any reads inside
+      # the transaction can't leave it stuck unable to upgrade to a write lock
+      # (see the wait transaction in #run_test).
+      result = Inferno::Application['db.connection'].transaction(mode: :immediate) do
         results_repo.create(
           params.merge(test_run_id: test_run.id, test_session_id: test_session.id)
         )

data/lib/inferno/version.rb

@@ -1,4 +1,4 @@
 module Inferno
   # Standard patterns for gem versions: https://guides.rubygems.org/patterns/
-  VERSION = '1.4.5'.freeze
+  VERSION = '1.4.6'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferno_core
 version: !ruby/object:Gem::Version
-  version: 1.4.5
+  version: 1.4.6
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -759,7 +759,6 @@ files:
 - lib/inferno/route_storage.rb
 - lib/inferno/spec_support.rb
 - lib/inferno/test_runner.rb
-- lib/inferno/utils/db_concurrency_check.rb
 - lib/inferno/utils/execution_script_runner.rb
 - lib/inferno/utils/ig_downloader.rb
 - lib/inferno/utils/markdown_formatter.rb

data/lib/inferno/utils/db_concurrency_check.rb

@@ -1,166 +0,0 @@
-require 'sequel'
-require 'sqlite3'
-require 'tmpdir'
-require 'securerandom'
-
-module Inferno
-  module Utils
-    # Verifies that the sqlite WAL/busy_timeout/transaction-wrapping in
-    # lib/inferno/config/boot/db.rb and TestRunner#persist_result actually
-    # prevent SQLITE_BUSY under concurrent test-run writes and status-polling
-    # reads against a shared sqlite file.
-    #
-    # This is deliberately NOT an rspec example. It's a real-time concurrency
-    # measurement, and a hardcoded load level that reliably reproduces (or
-    # avoids) SQLITE_BUSY on one machine does not transfer to others: a load
-    # level tuned to fail reliably without the fix and pass reliably with it,
-    # verified repeatedly on one machine, failed consistently in GitHub
-    # Actions and on another local machine. Rather than assert against a
-    # fixed load level, this calibrates to whatever machine it runs on: it
-    # escalates the write volume until it can demonstrate the *unprotected*
-    # configuration actually hits SQLITE_BUSY, then checks whether the
-    # *protected* configuration avoids it under that same, machine-calibrated
-    # load.
-    #
-    # Run manually with `bundle exec rake db:check_concurrency` after changing
-    # the persistence/locking behavior in the files above. It isn't part of
-    # the default test suite because it's a real-time measurement, not a
-    # deterministic assertion, and shouldn't gate CI.
-    module DbConcurrencyCheck
-      WRITER_THREADS = 5
-      READER_THREADS = 3
-      READER_POLL_INTERVAL = 0.2
-      MAX_CONNECTIONS = 15
-      MAX_CASCADES_PER_WRITER = 5000
-
-      module_function
-
-      def run
-        cascades = 10
-        baseline_errors = []
-
-        loop do
-          baseline_errors = measure(protected: false, cascades_per_writer: cascades)
-          break if baseline_errors.any? || cascades > MAX_CASCADES_PER_WRITER
-
-          cascades *= 2
-        end
-
-        if baseline_errors.empty?
-          puts "INCONCLUSIVE: could not reproduce SQLITE_BUSY even at #{cascades} cascades/writer on this machine."
-          return true
-        end
-
-        puts "Reproduced #{baseline_errors.size} SQLITE_BUSY error(s) without WAL/busy_timeout/transaction-" \
-             "wrapping at #{cascades} cascades/writer (#{WRITER_THREADS} writers, #{READER_THREADS} readers " \
-             "polling every #{READER_POLL_INTERVAL}s)."
-
-        protected_errors = measure(protected: true, cascades_per_writer: cascades)
-
-        if protected_errors.empty?
-          puts 'PASS: the current fix avoided SQLITE_BUSY under the same load that reproduced it above.'
-          true
-        else
-          puts "FAIL: the current fix still hit #{protected_errors.size} SQLITE_BUSY error(s) under the same load:"
-          puts protected_errors.first.message
-          false
-        end
-      end
-
-      def measure(protected:, cascades_per_writer:)
-        Dir.mktmpdir do |dir|
-          db = connect(File.join(dir, 'contention.db'), protected:)
-          result_class, request_class, header_class = build_schema_and_models(db)
-          errors = []
-          mutex = Mutex.new
-          stop_reading = false
-
-          writers = Array.new(WRITER_THREADS) do
-            Thread.new do
-              cascades_per_writer.times do
-                persist_cascade(db, result_class, request_class, header_class, protected:)
-              rescue StandardError => e
-                mutex.synchronize { errors << e }
-              end
-            end
-          end
-
-          readers = Array.new(READER_THREADS) do
-            Thread.new { poll_until(-> { stop_reading }, result_class, request_class, errors, mutex) }
-          end
-
-          writers.each(&:join)
-          stop_reading = true
-          readers.each(&:join)
-          db.disconnect
-
-          errors.select { |e| e.is_a?(Sequel::DatabaseError) && e.message =~ /database is locked|SQLITE_BUSY/i }
-        end
-      end
-
-      def connect(db_path, protected:)
-        connect_sqls =
-          if protected
-            ["PRAGMA busy_timeout = #{ENV.fetch('DB_BUSY_TIMEOUT_MS', '15000')}", 'PRAGMA journal_mode = WAL']
-          else
-            ['PRAGMA busy_timeout = 0']
-          end
-        Sequel.connect(adapter: 'sqlite', database: db_path, max_connections: MAX_CONNECTIONS, connect_sqls:)
-      end
-
-      def persist_cascade(db, result_class, request_class, header_class, protected:)
-        if protected
-          db.transaction { create_cascade(result_class, request_class, header_class) }
-        else
-          create_cascade(result_class, request_class, header_class)
-        end
-      end
-
-      def poll_until(stop, result_class, request_class, errors, mutex)
-        until stop.call
-          result_class.order(Sequel.desc(:id)).limit(1).all
-          request_class.order(Sequel.desc(:id)).limit(1).all
-          sleep(READER_POLL_INTERVAL)
-        end
-      rescue StandardError => e
-        mutex.synchronize { errors << e }
-      end
-
-      def build_schema_and_models(db)
-        db.create_table(:results) do
-          primary_key :id
-          column :test_id, String
-          column :result, String
-        end
-        db.create_table(:requests) do
-          primary_key :id
-          foreign_key :result_id, :results
-          column :verb, String
-        end
-        db.create_table(:headers) do
-          primary_key :id
-          foreign_key :request_id, :requests
-          column :name, String
-          column :value, String
-        end
-
-        [
-          Class.new(Sequel::Model(db[:results])),
-          Class.new(Sequel::Model(db[:requests])),
-          Class.new(Sequel::Model(db[:headers]))
-        ]
-      end
-
-      def create_cascade(result_class, request_class, header_class)
-        result = result_class.create(test_id: SecureRandom.uuid, result: 'pass')
-        3.times do
-          request = request_class.create(result_id: result.id, verb: 'GET')
-          2.times do |i|
-            header_class.create(request_id: request.id, name: "Header-#{i}", value: SecureRandom.hex(8))
-          end
-        end
-        result
-      end
-    end
-  end
-end