inferno_core 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d24d5fad7804605708193855dec5e392045301a3a02ed94136d02f659a5f45e
-  data.tar.gz: df3d42baee167e540a41f3d4a5bc53afd307751c695b4202e1886c910468736c
+  metadata.gz: f1318358aa5a9dfd3f856740eb3b02ca30c5a960893595e44631fea414906936
+  data.tar.gz: ddf3a22b024d5745efeead73eacc55a23d7c0b9841e57177df877ed46457dc3a
 SHA512:
-  metadata.gz: 5286cc2c1c41c90a48e81806330d366eb87157b9a8f7d6f183db7919486925af880707d0728b504b42356a701c206b4b4c7c0eed07762ea4cf4d5605b68934fe
-  data.tar.gz: 4e722dffacb5ffbff4fae5827718cac7d77ad331f4675c14db8a873766cb9a71cb690e0e3c1dbe16b7e9d6d5a0ba3e3b55ee2f247d07cc9133503870a6377c0b
+  metadata.gz: 5ddfa620841f6acb416190f683235fefeb089e623f238578ac7cd0022bc01ece6aee0644bae93b6d9f4ee72aff33fa4cefeda871a9a160502cd26dde0b193260
+  data.tar.gz: 718dcda3cd89f1f9d673eaa7596ec5dc8b4dd405b9434c6a55eb2caf381d2cd1516614098ac565d1104c410991ec6496b5e11ecfaf66df77b4d49df1ae5c569f

data/lib/inferno/apps/cli/execute_script.rb

@@ -137,7 +137,7 @@ module Inferno
       )
 
       ExecutionStatus = Struct.new(
-        :done, :failed, :timed_out, :current_session, :current_timeout, :last_log_time,
+        :done, :failed, :timed_out, :cancel_pending, :current_session, :current_timeout, :last_log_time,
         :cross_session_status, :last_step_signatures
       )
 
@@ -152,6 +152,7 @@ module Inferno
           done: false,
           failed: false,
           timed_out: false,
+          cancel_pending: false,
           current_session: sessions.first,
           current_timeout: options[:default_poll_timeout],
           cross_session_status: {},
@@ -234,13 +235,15 @@ module Inferno
         creator = Session::CreateSession.new(suite, session_create_options(session_config))
         session_details = creator.create_session
         key = session_config['name'] || suite
-        warn "Session created: #{session_details['id']}"
-        ScriptSession.new(
+        script_session = ScriptSession.new(
           key: key,
           suite_id: session_details['test_suite_id'],
           session_id: session_details['id'],
           short_id_map: extract_short_ids_from_session_details(session_details)
         )
+        warn "Session created: #{session_details['id']}"
+        warn "  Available at #{session_display_url(script_session)}"
+        script_session
       end
 
       def session_create_options(session_config)
@@ -442,6 +445,10 @@ module Inferno
 
       # Returns a step hash to act on, or nil to keep polling.
       def handle_actionable_status(status, session, timeout)
+        # A cancelled run's done status is indistinguishable from the
+        # runnable completing normally, so don't match steps against it.
+        return handle_cancel_completion(status, session, timeout) if execution_status.cancel_pending
+
         matched_step = match_step(status, session.key)
 
         if matched_step
@@ -463,10 +470,16 @@ module Inferno
         last_completed = format_last_completed(last_completed_from_status(status), session.key)
         warn "UNHANDLED WAIT - Canceling: session=#{session.key} last_completed=#{last_completed}"
         execution_status.failed = true
+        execution_status.cancel_pending = true
         attempt_cancel(session.session_id, status)
         nil
       end
 
+      def handle_cancel_completion(status, session, timeout)
+        warn "Cancellation complete: session=#{session.key} status=#{status['status']}"
+        { command: nil, timeout: timeout, next_poll_session: nil }
+      end
+
       def handle_unmatched_status(status, session, timeout)
         run_status = status['status']
         last_completed = format_last_completed(last_completed_from_status(status), session.key)
@@ -485,6 +498,7 @@ module Inferno
           execution_status.failed = true
           if run_status == 'waiting'
             warn "Loop detected - Canceling: session=#{session.key} last_completed=#{last_completed}"
+            execution_status.cancel_pending = true
             attempt_cancel(session.session_id, status)
             return nil
           else
@@ -504,10 +518,14 @@ module Inferno
         last_completed = last_completed_from_status(status)
         poll_status_last_test =
           last_completed.present? ? " - last test: #{format_last_completed(last_completed, session_key)}" : ''
-        warn "  [#{session_key}] #{status['status']}#{poll_status_last_test}"
+        warn "  [#{session_key}] #{status['status']} (#{test_progress(status)})#{poll_status_last_test}"
         execution_status.last_log_time = Time.now
       end
 
+      def test_progress(status)
+        "#{status['completed_test_count']}/#{status['test_count']} tests"
+      end
+
       def fetch_session_status(session_id)
         Session::SessionStatus.new(session_id, options).status_for_session
       end

data/lib/inferno/apps/cli/session/session_compare.rb

@@ -1,5 +1,6 @@
 require 'csv'
 require 'cgi'
+require 'uri'
 require_relative 'session_details'
 require_relative 'session_results'
 
@@ -82,16 +83,39 @@ module Inferno
         end
 
         def save_actual_results_to_file
-          actual_results_file_name = "#{output_file_prefix}actual_results_#{results_timestamp}.json"
-          File.write(File.join(output_directory, actual_results_file_name), session_results.to_json)
+          actual_results_file_name = "#{output_file_prefix}actual_results_#{results_timestamp}#{host_suffix}.json"
+          File.write(File.join(output_directory, actual_results_file_name), JSON.pretty_generate(session_results))
         end
 
         def save_comparison_csv_to_file
-          compared_csv_file_name = "#{output_file_prefix}compared_results_#{results_timestamp}.csv"
+          compared_csv_file_name = "#{output_file_prefix}compared_results_#{results_timestamp}#{host_suffix}.csv"
           File.write(File.join(output_directory, compared_csv_file_name),
                      compared_results_as_csv)
         end
 
+        # Filesystem-safe "_<host>" (plus non-default port, if any) suffix derived from
+        # the --inferno-base-url (-I) option, so output filenames can be disambiguated
+        # by target server. Empty when -I was not passed or the URL has no host.
+        def host_suffix
+          inferno_host_slug ? "_#{inferno_host_slug}" : ''
+        end
+
+        def inferno_host_slug
+          return nil unless options[:inferno_base_url].present?
+
+          uri = begin
+            URI.parse(options[:inferno_base_url])
+          rescue URI::InvalidURIError
+            nil
+          end
+          host = uri&.host
+          return nil unless host
+
+          slug = host.dup
+          slug << "_#{uri.port}" if uri.port && uri.port != uri.default_port
+          slug.gsub(/[^a-zA-Z0-9.-]/, '_')
+        end
+
         def display_compared_results
           output = {
             matched: results_match?,

data/lib/inferno/apps/cli/session/session_status.rb

@@ -27,7 +27,10 @@ module Inferno
 
           if session_status['id'].present?
             run_id = session_status['id']
-            last_test_executed = last_test_executed(run_id)
+            test_results = run_results(run_id).select { |result| result['test_id'].present? }
+            session_status['completed_test_count'] = test_results.size
+
+            last_test_executed = last_test_executed(test_results, session_status['status'])
             if last_test_executed.present?
               session_status['last_test_executed'] = last_test_executed['test_id']
               if session_status['status'] == 'waiting'
@@ -53,9 +56,22 @@ module Inferno
           }
         end
 
-        def last_test_executed(run_id)
-          results = run_results(run_id)
-          results.sort_by { |r| r['updated_at'] }.reverse.find { |result| result['test_id'].present? }
+        # Serialized updated_at values can collide when results are written in
+        # quick succession, so when the run is waiting, identify the waiting
+        # test by its 'wait' result rather than by timestamp order alone.
+        def last_test_executed(test_results, run_status)
+          if run_status == 'waiting'
+            wait_results = test_results.select { |result| result['result'] == 'wait' }
+            test_results = wait_results if wait_results.any?
+          end
+
+          most_recent_result(test_results)
+        end
+
+        # updated_at ties are broken by array position (later results win)
+        # since the API returns results in insertion order.
+        def most_recent_result(results)
+          results.each_with_index.max_by { |result, index| [result['updated_at'].to_s, index] }&.first
         end
 
         def run_results(run_id)

data/lib/inferno/apps/web/controllers/test_runs/create.rb

@@ -37,7 +37,14 @@ module Inferno
 
             persist_inputs(session_data_repo, req.params, test_run.runnable)
 
-            Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
+            Jobs.perform(
+              Jobs::ExecuteTestRun,
+              test_run.id,
+              tags: [
+                "session:#{test_session.id}",
+                "run:#{test_run.test_suite_id || test_run.test_group_id || test_run.test_id}"
+              ]
+            )
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
                  Inferno::Exceptions::RequiredInputsNotFound,
                  Inferno::Exceptions::NotUserRunnableException => e

data/lib/inferno/apps/web/controllers/test_runs/destroy.rb

@@ -22,7 +22,16 @@ module Inferno
             if test_run_is_waiting
               waiting_result = results_repo.find_waiting_result(test_run_id: test_run.id)
               results_repo.update_result(waiting_result.id, 'cancel', 'Test cancelled by user')
-              Jobs.perform(Jobs::ResumeTestRun, test_run.id)
+              Jobs.perform(
+                Jobs::ResumeTestRun,
+                test_run.id,
+                tags: [
+                  'source:delete',
+                  "session:#{test_run.test_session_id}",
+                  "run:#{test_run.test_suite_id || test_run.test_group_id || test_run.test_id}",
+                  "test:#{waiting_result.test_id}"
+                ]
+              )
             end
 
             res.status = 204

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

@@ -1,6 +1,46 @@
 require 'sequel'
 require 'erb'
 
+module Inferno
+  module Config
+    module Boot
+      # Extracted from the :db provider below so the sqlite-only branching can
+      # be unit tested with plain config hashes/doubles, instead of requiring
+      # a real postgres connection (which this project has no infrastructure
+      # for) just to exercise the non-sqlite path.
+      module Db
+        module_function
+
+        # The web and worker processes each hold their own pool of connections to the
+        # same sqlite file, so writes from one process can easily collide with reads
+        # 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'
+
+          connect_sqls = ["PRAGMA busy_timeout = #{ENV.fetch('DB_BUSY_TIMEOUT_MS', '15000')}"]
+          connect_sqls << 'PRAGMA journal_mode = WAL' unless config['database'] == ':memory:'
+          config['connect_sqls'] = connect_sqls
+          config
+        end
+
+        def log_sqlite_journal_mode(config, connection, logger)
+          return unless config['adapter'] == 'sqlite'
+
+          actual_journal_mode = connection.fetch('PRAGMA journal_mode').first[:journal_mode]
+          logger.info("sqlite journal_mode: #{actual_journal_mode}")
+        end
+      end
+    end
+  end
+end
+
 Inferno::Application.register_provider(:db) do
   prepare do
     target_container.start :logging
@@ -13,6 +53,9 @@ Inferno::Application.register_provider(:db) do
     config_contents = ERB.new(File.read(config_path)).result
     config = YAML.safe_load(config_contents)[ENV.fetch('APP_ENV', nil)]
       .merge(logger: Inferno::Application['logger'])
+
+    Inferno::Config::Boot::Db.configure_sqlite_pragmas!(config)
+
     connection_attempts_remaining = ENV.fetch('MAX_DB_CONNECTION_ATTEMPTS', '10').to_i
     connection_retry_delay = ENV.fetch('DB_CONNECTION_RETRY_DELAY', '5').to_i
     connection = nil
@@ -31,6 +74,8 @@ Inferno::Application.register_provider(:db) do
     end
     connection.sql_log_level = :debug
 
+    Inferno::Config::Boot::Db.log_sqlite_journal_mode(config, connection, Inferno::Application['logger'])
+
     register('db.config', config)
     register('db.connection', connection)
   end

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

@@ -7,6 +7,10 @@ Inferno::Application.register_provider(:executor) do
 
     Blueprinter.configure do |config|
       config.generator = Oj
+      # Oj >= 3.17 no longer honors ActiveSupport's Time#to_json, which
+      # dropped sub-second precision from serialized timestamps. Clients
+      # order results by these strings, so keep millisecond precision.
+      config.datetime_format = '%FT%T.%L%:z'
     end
 
     target_container.start :suites

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

@@ -5,6 +5,10 @@ Inferno::Application.register_provider(:web) do |_app|
 
     Blueprinter.configure do |config|
       config.generator = Oj
+      # Oj >= 3.17 no longer honors ActiveSupport's Time#to_json, which
+      # dropped sub-second precision from serialized timestamps. Clients
+      # order results by these strings, so keep millisecond precision.
+      config.datetime_format = '%FT%T.%L%:z'
     end
 
     # Workers aren't connected to a web server, so they shouldn't be hosting

data/lib/inferno/dsl/input_output_handling.rb

@@ -193,14 +193,16 @@ module Inferno
               inputs[input.name.to_sym] = Entities::Input.new(**input.to_hash)
             end
 
+        # children_available_inputs walks the entire subtree, so it is computed once here
+        # rather than once per input. merge_with_child only mutates its receiver, so the
+        # child definitions are safe to reuse for the merge below.
+        child_inputs = children_available_inputs(selected_suite_options)
+
         available_inputs.each do |input, current_definition|
-          child_definition = children_available_inputs(selected_suite_options)[input]
-          current_definition.merge_with_child(child_definition)
+          current_definition.merge_with_child(child_inputs[input])
         end
 
-        available_inputs = children_available_inputs(selected_suite_options).merge(available_inputs)
-
-        order_available_inputs(available_inputs)
+        order_available_inputs(child_inputs.merge(available_inputs))
       end
     end
   end

data/lib/inferno/dsl/resume_test_route.rb

@@ -94,7 +94,16 @@ module Inferno
         update_result(waiting_result, result_message)
         persist_request(request, test_run, waiting_result, test)
 
-        Jobs.perform(Jobs::ResumeTestRun, test_run.id)
+        Jobs.perform(
+          Jobs::ResumeTestRun,
+          test_run.id,
+          tags: [
+            'source:route',
+            "session:#{test_run.test_session_id}",
+            "run:#{test_run.test_suite_id || test_run.test_group_id || test_run.test_id}",
+            "test:#{test.id}"
+          ]
+        )
 
         res.redirect_to redirect_route(test_run, test)
       end

data/lib/inferno/dsl/suite_endpoint.rb

@@ -254,6 +254,8 @@ module Inferno
       def resume
         req.env['inferno.resume_test_run'] = true
         req.env['inferno.test_run_id'] = test_run.id
+        req.env['inferno.run_identifier'] = test_run.test_suite_id || test_run.test_group_id || test_run.test_id
+        req.env['inferno.waiting_test_id'] = test.id
       end
 
       # @private
@@ -318,7 +320,16 @@ module Inferno
             test_run_id = env['inferno.test_run_id']
             Inferno::Repositories::TestRuns.new.mark_as_no_longer_waiting(test_run_id)
 
-            Inferno::Jobs.perform(Jobs::ResumeTestRun, test_run_id)
+            Inferno::Jobs.perform(
+              Jobs::ResumeTestRun,
+              test_run_id,
+              tags: [
+                'source:suite_endpoint',
+                "session:#{env['inferno.test_session_id']}",
+                "run:#{env['inferno.run_identifier']}",
+                "test:#{env['inferno.waiting_test_id']}"
+              ]
+            )
           end
         rescue StandardError => e
           logger.error(e.full_message)

data/lib/inferno/jobs.rb

@@ -6,9 +6,13 @@ require_relative 'jobs/invoke_validator_session'
 
 module Inferno
   module Jobs
-    def self.perform(job_klass, *params, force_synchronous: false)
+    def self.perform(job_klass, *params, force_synchronous: false, tags: nil)
+      tags = Array(tags).compact
+
       if force_synchronous || (Application['async_jobs'] == false)
         job_klass.new.perform(*params)
+      elsif tags.any?
+        job_klass.set(tags:).perform_async(*params)
       else
         job_klass.perform_async(*params)
       end

data/lib/inferno/test_runner.rb

@@ -75,20 +75,27 @@ module Inferno
       outputs = save_outputs(test_instance)
       output_json_string = JSON.generate(outputs)
 
-      if result == 'wait'
-        test_runs_repo.mark_as_waiting(test_run.id, test_instance.identifier, test_instance.wait_timeout)
-      end
-
-      test_result = persist_result(
-        {
-          messages: test_instance.messages,
-          requests: test_instance.requests,
-          result:,
-          result_message: test_instance.result_message,
-          input_json: input_json_string,
-          output_json: output_json_string
-        }.merge(test.reference_hash)
-      )
+      result_params = {
+        messages: test_instance.messages,
+        requests: test_instance.requests,
+        result:,
+        result_message: test_instance.result_message,
+        input_json: input_json_string,
+        output_json: output_json_string
+      }.merge(test.reference_hash)
+
+      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.
@@ -249,9 +256,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.2'.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.2
 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-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -756,6 +756,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