inferno_core 1.4.1 → 1.4.3

data/lib/inferno/public/bundle.js.LICENSE.txt

@@ -1,5 +1,3 @@
-/*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
-
 /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
 
 /**

data/lib/inferno/test_runner.rb

@@ -59,28 +59,24 @@ module Inferno
     end
 
     def run_test(test, scratch)
-      inputs = load_inputs(test)
-      input_json_string = inputs_as_json(test, inputs)
-
-      test_instance =
-        test.new(
-          inputs:,
-          test_session_id: test_session.id,
-          scratch:,
-          suite_options: test_session.suite_options_hash
-        )
+      around_test(test) do
+        inputs = load_inputs(test)
+        input_json_string = inputs_as_json(test, inputs)
 
-      result = evaluate_runnable_result(test, test_instance, inputs)
+        test_instance =
+          test.new(
+            inputs:,
+            test_session_id: test_session.id,
+            scratch:,
+            suite_options: test_session.suite_options_hash
+          )
 
-      outputs = save_outputs(test_instance)
-      output_json_string = JSON.generate(outputs)
+        result = evaluate_runnable_result(test, test_instance, inputs)
 
-      if result == 'wait'
-        test_runs_repo.mark_as_waiting(test_run.id, test_instance.identifier, test_instance.wait_timeout)
-      end
+        outputs = save_outputs(test_instance)
+        output_json_string = JSON.generate(outputs)
 
-      test_result = persist_result(
-        {
+        result_params = {
           messages: test_instance.messages,
           requests: test_instance.requests,
           result:,
@@ -88,15 +84,41 @@ module Inferno
           input_json: input_json_string,
           output_json: output_json_string
         }.merge(test.reference_hash)
-      )
 
-      # If running a single test, update its parents' results. If running a
-      # group or suite, #run_group handles updating the parents.
-      return test_result if test_run.test_id.blank?
-
-      update_parent_result(test.parent)
+        test_result =
+          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
+              test_runs_repo.mark_as_waiting(test_run.id, test_instance.identifier, test_instance.wait_timeout)
+              persist_result(result_params)
+            end
+          else
+            persist_result(result_params)
+          end
+
+        # If running a single test, update its parents' results. If running a
+        # group or suite, #run_group handles updating the parents.
+        update_parent_result(test.parent) if test_run.test_id.present?
+
+        test_result
+      end
+    end
 
-      test_result
+    # Wraps the execution of a single test. Prepend a module overriding this method
+    # to run instrumentation around each test, for example to emit a distinct trace,
+    # span, or timing metric per test instead of one that spans the whole run.
+    #
+    # An override must call `super` exactly once and return its value unchanged:
+    # it is the test's result, and parent results are rolled up from it. An
+    # override that does not call `super` silently skips the test.
+    #
+    # @param test [Class] the test being run (an Inferno::Entities::Test subclass)
+    # @yield executes the test and returns its result
+    # @return the value returned by the block
+    def around_test(_test)
+      yield
     end
 
     def check_inputs(test, _test_instance, inputs)
@@ -249,9 +271,20 @@ module Inferno
     end
 
     def persist_result(params)
-      result = results_repo.create(
-        params.merge(test_run_id: test_run.id, test_session_id: test_session.id)
-      )
+      # A single result can cascade into many separate inserts (messages,
+      # requests, headers, tags). Wrapping them in one transaction turns that
+      # 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
+        results_repo.create(
+          params.merge(test_run_id: test_run.id, test_session_id: test_session.id)
+        )
+      end
 
       run_results[result.runnable.id] = result
     end

data/lib/inferno/utils/db_concurrency_check.rb

@@ -0,0 +1,166 @@
+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

data/lib/inferno/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferno_core
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.3
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -678,6 +678,7 @@ files:
 - lib/inferno/dsl/must_support_metadata_extractor.rb
 - lib/inferno/dsl/oauth_credentials.rb
 - lib/inferno/dsl/primitive_type.rb
+- lib/inferno/dsl/profile_metadata.rb
 - lib/inferno/dsl/request_storage.rb
 - lib/inferno/dsl/requirement_set.rb
 - lib/inferno/dsl/result_collection.rb
@@ -756,6 +757,7 @@ 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