inferno_core 1.4.4 → 1.4.6

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
@@ -122,9 +126,13 @@ module Inferno
     end
 
     def check_inputs(test, _test_instance, inputs)
+      available_inputs = test.available_inputs(test_session.suite_options)
+      input_values = inputs.transform_keys { |input_identifier| test.config.input_name(input_identifier).to_s }
+
       inputs.each do |key, value|
         optional = test.config.input_optional?(key)
-        if value.nil? && !optional
+        input = available_inputs[test.config.input_name(key).to_sym]
+        if value.nil? && !optional && input.enabled?(input_values, available_inputs)
           raise Exceptions::SkipException,
                 "Input '#{test.config.input_name(key)}' is nil, skipping test."
         end
@@ -276,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.4'.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.4
+  version: 1.4.6
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-04 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