inferno_core 1.4.5 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cffc2d9b151af63840789863f04e8551fd82077351f85d356b5a88f103f28f2
-  data.tar.gz: c6687758255cf5acadb700dfd268ee65f6ab03713dbc17ec412d1240d7f352b7
+  metadata.gz: e77b2567061750720f73082094abe8f2906e060f362842640725481824dea6f3
+  data.tar.gz: 7b7ba8fa843ab58166f725b7939a74311825f959158b5eea06d954dbf1c9fe50
 SHA512:
-  metadata.gz: 0f7ca455177f14a4f0ad5dae5852a7b7441e7ef867e554678b8d55410d623cb7b1d0e4e4432dbd8f1c8cdc085943801d2b98601d9ea776cd1e93f6482a02e3b9
-  data.tar.gz: d4160ba11c06d24fc185c2b4cde86fc36c519499f383c79053246114b2e69d0e5be4504e87ea476f462e1439383f8c1a07a5efcab2701449cbd6458939faa13b
+  metadata.gz: 19f220a5663640cc07eb0182321aad839126f89e0e85b3c7c9d98971c4cde72b591fc5c86013c3cd8db3fc07f01bd08847b5b98ed82213c4819d75ddcf46a1e5
+  data.tar.gz: c0b1ba31490d081c3e4d351efa9ac182996952366e20b96fa75ec9e7fb816c01dbdba3c7d857746b45455181a098ee2b78fd2b389b65d1b2d0ec7179504d4482

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/fhir_resource_navigation.rb

@@ -252,16 +252,18 @@ module Inferno
 
       # @private
       def matching_pattern_codeable_concept_slice?(slice, discriminator)
-        slice_value = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s)&.coding : slice.coding
-        slice_value&.any? do |coding|
+        codings = resolve_path(slice, discriminator[:path])
+          .flat_map { |codeable_concept| Array.wrap(codeable_concept.coding) }
+        codings.any? do |coding|
           coding.code == discriminator[:code] && coding.system == discriminator[:system]
         end
       end
 
       # @private
       def matching_pattern_coding_slice?(slice, discriminator)
-        slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
-        slice_value&.code == discriminator[:code] && slice_value&.system == discriminator[:system]
+        resolve_path(slice, discriminator[:path]).any? do |coding|
+          coding.code == discriminator[:code] && coding.system == discriminator[:system]
+        end
       end
 
       # @private
@@ -323,7 +325,10 @@ module Inferno
           when String
             value == coding.code
           when Hash
-            value[:system] == coding.system && value[:code] == coding.code
+            next false unless value[:system] == coding.system
+
+            # A value without a code stands for every code in its system
+            value[:code].nil? ? coding.code.present? : value[:code] == coding.code
           end
         end
       end

data/lib/inferno/dsl/must_support_assessment.rb

@@ -1,3 +1,5 @@
+require_relative 'must_support_strings'
+
 module Inferno
   module DSL
     # The MustSupportAssessment module contains the logic for tests
@@ -23,7 +25,7 @@ module Inferno
       #        test kits can subclass to build these objects, eg from generated YAML, instead of hand-rolling one.
       # @param requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
       # @yield [MustSupportMetadataExtractor] Customize the metadata before running the test
-      # @return [Array<String>] List of missing elements
+      # @return [Array<String>] List of missing elements, sorted alphabetically
       def missing_must_support_elements(resources, profile_url, validator_name: :default, metadata: nil,
                                         requirement_extension: nil, &)
         debug_metadata = config.options[:debug_must_support_metadata]
@@ -141,7 +143,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 +176,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)
@@ -185,18 +197,17 @@ module Inferno
           end
         end
 
+        # See {MustSupportStrings} for how each missing item is represented. Sorted to match
+        # {ProfileMetadata#must_support_strings}.
         def missing_must_support_strings
-          missing_elements.map { |element_definition| missing_element_string(element_definition) } +
-            missing_slices.map { |slice_definition| slice_definition[:slice_id] } +
-            missing_extensions.map { |extension_definition| extension_definition[:id] }
+          (missing_elements.map { |element_definition| missing_element_string(element_definition) } +
+            missing_slices.map { |slice_definition| MustSupportStrings.slice_string(slice_definition) } +
+            missing_extensions.map { |extension_definition| MustSupportStrings.extension_string(extension_definition) })
+            .sort
         end
 
         def missing_element_string(element_definition)
-          if element_definition[:fixed_value].present?
-            "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
-          else
-            element_definition[:path]
-          end
+          MustSupportStrings.element_string(element_definition)
         end
 
         def must_support_extensions
@@ -303,28 +314,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)
 
@@ -464,17 +453,6 @@ module Inferno
         def find_slice_by_values(element, value_definitions)
           Array.wrap(element).find { |el| verify_slice_by_values(el, value_definitions) }
         end
-
-        def required_binding_value_match?(coding, values)
-          values.any? do |value|
-            case value
-            when String
-              value == coding.code
-            when Hash
-              value[:system] == coding.system && value[:code] == coding.code
-            end
-          end
-        end
       end
     end
   end

data/lib/inferno/dsl/must_support_strings.rb

@@ -0,0 +1,62 @@
+module Inferno
+  module DSL
+    # Builds the strings used to identify Must Support elements, slices, and extensions from their
+    # metadata, so that lists of what is expected to be supported (eg {ProfileMetadata#must_support_strings})
+    # and lists of what is missing (eg {MustSupportAssessment#missing_must_support_elements}) agree.
+    #
+    # Each item is represented by its ElementDefinition id (which includes the names of any parent
+    # slices) without the leading resource type, eg 'category:us-core' rather than
+    # 'Condition.category:us-core'. Elements with a fixed value have it appended, eg 'name.use = old'.
+    # @private
+    module MustSupportStrings
+      module_function
+
+      # @param element_definition [Hash] Must Support element metadata
+      # @return [String]
+      def element_string(element_definition)
+        path = element_display_path(element_definition)
+
+        fixed_value = element_definition[:fixed_value]
+        if fixed_value.present? || fixed_value == false
+          "#{path} = #{fixed_value}"
+        else
+          path
+        end
+      end
+
+      # @param slice_definition [Hash] Must Support slice metadata
+      # @return [String]
+      def slice_string(slice_definition)
+        id_string(slice_definition, :slice_id)
+      end
+
+      # @param extension_definition [Hash] Must Support extension metadata
+      # @return [String]
+      def extension_string(extension_definition)
+        id_string(extension_definition, :id)
+      end
+
+      # Elements under a choice type slice (eg value[x]:valueQuantity.value) have their navigation
+      # path rewritten so the slice name is mangled (eg valueQuantity:valueQuantity.value), so report
+      # the original path instead. Elements where only some types of a choice are Must Support
+      # (eg original path effective[x], path effectiveDateTime) keep their path since it names the type.
+      def element_display_path(element_definition)
+        original_path = element_definition[:original_path]
+        original_path&.include?('[x]:') ? original_path : element_definition[:path]
+      end
+
+      def id_string(definition, id_key)
+        id = definition[id_key]
+        raise ArgumentError, "Must Support metadata is missing #{id_key.inspect}: #{definition.inspect}" if id.blank?
+
+        without_resource_type(id)
+      end
+
+      # Resource types are PascalCase while element names are camelCase, so a leading
+      # capitalized segment is the resource type prefix of an ElementDefinition id.
+      def without_resource_type(id)
+        id&.sub(/\A[A-Z][A-Za-z0-9]*\./, '')
+      end
+    end
+  end
+end

data/lib/inferno/dsl/profile_metadata.rb

@@ -1,3 +1,5 @@
+require_relative 'must_support_strings'
+
 module Inferno
   module DSL
     # A ProfileMetadata object is a small, inheritable data holder for generated metadata about a
@@ -85,29 +87,18 @@ module Inferno
       # check, this includes everything that's expected to be supported, not just what's absent
       # from a particular set of resources.
       #
-      # Elements are represented as their `path`, with the matched `fixed_value` appended after a
-      # colon where present (eg `"code.coding.code:45473-6"`). Slices and extensions are
-      # represented as their `path`, with their `slice_name` appended after a colon where present
-      # (eg `"category:us-core"`, `"extension:us-core-race"`).
+      # Each item is represented the same way as in the list returned by a missing-elements check:
+      # by its ElementDefinition id (including the names of any parent slices) without the leading
+      # resource type (eg `"category:us-core"`, `"extension:us-core-race"`), with any matched
+      # `fixed_value` appended to elements (eg `"code.coding.code = 45473-6"`). See {MustSupportStrings}.
       # @return [Array<String>]
       def must_support_strings
-        element_strings =
-          Array.wrap(must_supports[:elements]).map do |element|
-            must_support_string(element[:path], element[:fixed_value])
-          end
-        slice_strings =
-          Array.wrap(must_supports[:slices]).map { |slice| must_support_string(slice[:path], slice[:slice_name]) }
-        extension_strings =
-          Array.wrap(must_supports[:extensions]).map { |ext| must_support_string(ext[:path], ext[:slice_name]) }
+        element_strings = Array.wrap(must_supports[:elements]).map { |el| MustSupportStrings.element_string(el) }
+        slice_strings = Array.wrap(must_supports[:slices]).map { |slice| MustSupportStrings.slice_string(slice) }
+        extension_strings = Array.wrap(must_supports[:extensions]).map { |ex| MustSupportStrings.extension_string(ex) }
 
         (element_strings + slice_strings + extension_strings).sort
       end
-
-      private
-
-      def must_support_string(path, suffix)
-        suffix.present? ? "#{path}:#{suffix}" : path
-      end
     end
   end
 end

data/lib/inferno/dsl/value_extractor.rb

@@ -60,9 +60,8 @@ module Inferno
       def bound_systems_from_valueset_include_element(include_element)
         if include_element.concept.present?
           include_element
-        elsif include_element.system.present? && include_element.filter&.empty?
-          # Cannot process intensional value set with filters
-          ig_resources.code_system_by_url(include_element.system)
+        elsif whole_code_system_include?(include_element)
+          whole_code_system(include_element)
         elsif include_element.valueSet.present?
           include_element.valueSet.map do |vs|
             a_value_set = ig_resources.value_set_by_url(vs)
@@ -71,6 +70,18 @@ module Inferno
         end
       end
 
+      def whole_code_system_include?(include_element)
+        include_element.system.present? && include_element.concept.blank? &&
+          include_element.filter&.empty? && include_element.valueSet.blank?
+      end
+
+      # An include of a whole code system lists no codes. Use the code system's concepts when the IG
+      # has them, otherwise keep the include so that any code from its system is accepted.
+      def whole_code_system(include_element)
+        code_system = ig_resources.code_system_by_url(include_element.system)
+        code_system&.concept.present? ? code_system : include_element
+      end
+
       def codes_from_value_set_binding(the_element)
         codes_from_system_code_pair(codings_from_value_set_binding(the_element))
       end
@@ -99,7 +110,7 @@ module Inferno
         bound_systems.flat_map do |bound_system|
           case bound_system
           when FHIR::ValueSet::Compose::Include
-            bound_system.concept.map { |concept| { system: bound_system.system, code: concept.code } }
+            codings_from_include(bound_system)
           when FHIR::CodeSystem
             bound_system.concept.map { |concept| { system: bound_system.url, code: concept.code } }
           else
@@ -108,6 +119,13 @@ module Inferno
         end.uniq
       end
 
+      # A whole code system include becomes a system-only value
+      def codings_from_include(include_element)
+        return [{ system: include_element.system }] if include_element.concept.blank?
+
+        include_element.concept.map { |concept| { system: include_element.system, code: concept.code } }
+      end
+
       def value_set_expansion_contains(element)
         value_set(element)&.expansion&.contains
       end

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.5.0'.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.5.0
 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-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -400,14 +400,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.10.1
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -678,6 +678,7 @@ files:
 - lib/inferno/dsl/messages.rb
 - lib/inferno/dsl/must_support_assessment.rb
 - lib/inferno/dsl/must_support_metadata_extractor.rb
+- lib/inferno/dsl/must_support_strings.rb
 - lib/inferno/dsl/oauth_credentials.rb
 - lib/inferno/dsl/primitive_type.rb
 - lib/inferno/dsl/profile_metadata.rb
@@ -759,7 +760,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