inferno_core 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1318358aa5a9dfd3f856740eb3b02ca30c5a960893595e44631fea414906936
-  data.tar.gz: ddf3a22b024d5745efeead73eacc55a23d7c0b9841e57177df877ed46457dc3a
+  metadata.gz: 044cfcbc6d3920cfba55d0d63fbf0fb3a1440f4f42a2e45d763beb78f280306a
+  data.tar.gz: 243c006acc71fddd3eb165a2c400a1eab4e515f8c3f4915b27cd60fc8e41e734
 SHA512:
-  metadata.gz: 5ddfa620841f6acb416190f683235fefeb089e623f238578ac7cd0022bc01ece6aee0644bae93b6d9f4ee72aff33fa4cefeda871a9a160502cd26dde0b193260
-  data.tar.gz: 718dcda3cd89f1f9d673eaa7596ec5dc8b4dd405b9434c6a55eb2caf381d2cd1516614098ac565d1104c410991ec6496b5e11ecfaf66df77b4d49df1ae5c569f
+  metadata.gz: a1c934c0c6bb863a66e34b2830807ee274f443323d7c74c10023bf078329abf2bc70d9125f481b388c3e9ac61a647c81a8f6ee6f7c156078a9dc4fc31adcb671
+  data.tar.gz: 6a54d11609e88fadd4c4750966e66a1df705ab1a1c79b8c8c0b99f5d3a19467496c46db740dfb2937610c9c78e8a7bf14db7fe8112c7c8399bb43a16bdcd6937

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

@@ -138,7 +138,7 @@ module Inferno
 
       ExecutionStatus = Struct.new(
         :done, :failed, :timed_out, :cancel_pending, :current_session, :current_timeout, :last_log_time,
-        :cross_session_status, :last_step_signatures
+        :poll_start_time, :cross_session_status, :last_step_signatures
       )
 
       attr_accessor :yaml_file, :options, :execution_status
@@ -155,6 +155,7 @@ module Inferno
           cancel_pending: false,
           current_session: sessions.first,
           current_timeout: options[:default_poll_timeout],
+          poll_start_time: nil,
           cross_session_status: {},
           last_step_signatures: {}
         )
@@ -416,6 +417,7 @@ module Inferno
         warn ''
         warn "Polling session: #{session.key} (#{session.session_id}) timeout=#{timeout}s"
         deadline = Time.now + timeout
+        execution_status.poll_start_time = Time.now
         execution_status.last_log_time = Time.now - LOG_INTERVAL_SECONDS
 
         loop do
@@ -518,12 +520,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']} (#{test_progress(status)})#{poll_status_last_test}"
+        elapsed = (Time.now - execution_status.poll_start_time).round
+        warn "  [#{session_key}] #{status['status']} (#{test_progress(status, elapsed)})" \
+             "#{poll_status_last_test}"
         execution_status.last_log_time = Time.now
       end
 
-      def test_progress(status)
-        "#{status['completed_test_count']}/#{status['test_count']} tests"
+      def test_progress(status, elapsed)
+        "completed #{status['completed_test_count']}/#{status['test_count']} tests in #{elapsed}s"
       end
 
       def fetch_session_status(session_id)

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

@@ -119,7 +119,7 @@ module Inferno
             suite_runnables.select { |runnable| runnable.verifies_requirements.include? requirement_id }
 
           runnables_for_requirement.map do |runnable|
-            [requirement_id, runnable.short_id, runnable.id]
+            [requirement_id, runnable < Inferno::Entities::TestSuite ? 'suite' : runnable.short_id, runnable.id]
           end
         end
       end

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -42,8 +42,13 @@ module Inferno
       # @param given_element [FHIR::Model, Array<FHIR::Model>]
       # @param path [String]
       # @param include_dar [Boolean]
+      # @param recursive_segments [Array<String>] names of path segments that are
+      #   self-referential (eg. `item` in Questionnaire.item.item, via a FHIR
+      #   `contentReference`). When a segment matches, the search also continues
+      #   into deeper repeats of that segment (item.item.item...) if the value
+      #   isn't found at the literal path depth.
       # @return a single matching value (which can include `false`) or `nil` if not found
-      def find_a_value_at(given_element, path, include_dar: false, &block)
+      def find_a_value_at(given_element, path, include_dar: false, recursive_segments: [], &block)
         return nil if given_element.nil?
 
         elements = Array.wrap(given_element)
@@ -56,8 +61,13 @@ module Inferno
         remaining_path = path_segments.join('.')
         elements.each do |element|
           child = get_next_value(element, segment)
-          element_found = find_a_value_at(child, remaining_path, include_dar:, &block)
+          element_found = find_a_value_at(child, remaining_path, include_dar:, recursive_segments:, &block)
           return element_found if value_not_empty?(element_found)
+
+          next unless recursive_segments.include?(segment)
+
+          nested_found = find_a_value_at(child, path, include_dar:, recursive_segments:, &block)
+          return nested_found if value_not_empty?(nested_found)
         end
 
         nil

data/lib/inferno/dsl/fhir_resource_validation.rb

@@ -26,6 +26,7 @@ module Inferno
     #       allowExampleUrls true
     #       txServer nil
     #     end
+    #     expansion_parameters 'path/to/expansion_parameters.json'
     #   end
     module FHIRResourceValidation
       def self.included(klass)
@@ -118,6 +119,99 @@ module Inferno
 
         alias cli_context validation_context
 
+        # Environment variable containing the default expansion parameters.
+        # Used by {#expansion_parameters} when no value has been set
+        # explicitly. May contain either the raw JSON content of a FHIR
+        # Parameters resource (if it starts with `{`) or a path to a file
+        # containing one.
+        EXPANSION_PARAMETERS_ENV_VAR = 'FHIR_RESOURCE_VALIDATOR_EXPANSION_PARAMETERS'.freeze
+
+        # Set the expansion parameters to be sent with each validation
+        # request. This configures how the validator's terminology engine
+        # expands value sets during validation (e.g. designation
+        # preferences, forcing the use of the latest terminology versions,
+        # etc.). The content is sent inline with every validation request
+        # made by this validator, since the validator does not have access
+        # to Inferno's filesystem.
+        #
+        # Accepts either a Hash containing the contents of a FHIR Parameters
+        # resource, or a String path to a file (JSON or XML) containing one.
+        # The file is read once, the first time it's needed.
+        #
+        # If never set explicitly, this falls back to the
+        # `FHIR_RESOURCE_VALIDATOR_EXPANSION_PARAMETERS` environment
+        # variable, if present. This allows a shared set of expansion
+        # parameters to be configured once for every test kit that uses a
+        # given validator instance, while still letting individual test
+        # kits opt out or override it by calling this method themselves.
+        # The environment variable's content is treated as raw JSON if it
+        # starts with `{`, and otherwise as a file path.
+        #
+        # @example
+        #   # Passing a Hash
+        #   fhir_resource_validator do
+        #     url 'http://example.com/validator'
+        #     expansion_parameters({
+        #       resourceType: 'Parameters',
+        #       parameter: [{ name: 'excludeNested', valueBoolean: true }]
+        #     })
+        #   end
+        #
+        # @example
+        #   # Passing a file path
+        #   fhir_resource_validator do
+        #     url 'http://example.com/validator'
+        #     expansion_parameters 'path/to/expansion_parameters.json'
+        #   end
+        #
+        # @param value [Hash, String, nil] contents of a Parameters resource
+        #   as a Hash, or a path to a file (JSON or XML) containing one
+        def expansion_parameters(value = nil)
+          if value
+            @expansion_parameters = build_expansion_parameters(value)
+          elsif !@expansion_parameters_resolved
+            env_value = ENV.fetch(EXPANSION_PARAMETERS_ENV_VAR, nil)
+            @expansion_parameters = build_expansion_parameters_from_env(env_value) if env_value
+          end
+          @expansion_parameters_resolved = true
+
+          @expansion_parameters
+        end
+
+        # @private
+        # Determines whether the environment variable's content is raw JSON
+        # or a file path based on its first non-whitespace character.
+        def build_expansion_parameters_from_env(env_value)
+          if env_value.lstrip.start_with?('{')
+            build_expansion_parameters_from_json_content(env_value)
+          else
+            build_expansion_parameters(env_value)
+          end
+        end
+
+        # @private
+        def build_expansion_parameters(value)
+          case value
+          when Hash
+            build_expansion_parameters_from_json_content(value.to_json)
+          else
+            {
+              fileName: File.basename(value),
+              fileContent: File.read(value),
+              fileType: nil
+            }
+          end
+        end
+
+        # @private
+        def build_expansion_parameters_from_json_content(json_content)
+          {
+            fileName: 'expansion_parameters.json',
+            fileContent: json_content,
+            fileType: nil
+          }
+        end
+
         # @private
         # Used internally by perform_additional_validation
         def additional_validations
@@ -622,6 +716,8 @@ module Inferno
             ],
             sessionId: @session_id
           }
+          wrapped_resource[:expansionParameters] = expansion_parameters if expansion_parameters
+
           wrapped_resource.to_json
         end
       end

data/lib/inferno/dsl/must_support_assessment.rb

@@ -15,10 +15,14 @@ module Inferno
       # @param resources [Array<FHIR::Resource>]
       # @param profile_url [String]
       # @param validator_name [Symbol] Name of the FHIR Validator that references the IG the profile is in
-      # @param metadata [Hash] MustSupport Metadata (optional),
-      #        if provided the check will use this instead of re-generating metadata from the profile
+      # @param metadata [Inferno::DSL::ProfileMetadata, #must_supports] MustSupport Metadata (optional),
+      #        if provided the check will use this instead of re-generating metadata from the profile.
+      #        Must respond to `#must_supports`, returning a Hash with `:elements`, `:extensions`, and
+      #        `:slices` keys (and optionally `:choices` and `:recursive_elements`) -- the shape produced by
+      #        {MustSupportMetadataExtractor#must_supports}. {Inferno::DSL::ProfileMetadata} is a base class
+      #        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 [Metadata] Customize the metadata before running the test
+      # @yield [MustSupportMetadataExtractor] Customize the metadata before running the test
       # @return [Array<String>] List of missing elements
       def missing_must_support_elements(resources, profile_url, validator_name: :default, metadata: nil,
                                         requirement_extension: nil, &)
@@ -199,6 +203,12 @@ module Inferno
           metadata.must_supports[:extensions]
         end
 
+        # Names of path segments that are self-referential (eg 'item' in Questionnaire.item.item)
+        # and so should be searched at any depth of nesting, not just the literal depth of a path.
+        def recursive_element_segments
+          Array.wrap(metadata.must_supports[:recursive_elements])
+        end
+
         def missing_extensions(resources = [])
           @missing_extensions ||=
             must_support_extensions.select do |extension_definition|
@@ -212,7 +222,7 @@ module Inferno
                     normalized_extension_url(extension.url) == expected_url
                   end
                 else
-                  extension = find_a_value_at(resource, path) do |el|
+                  extension = find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |el|
                     normalized_extension_url(el.url) == expected_url
                   end
 
@@ -243,9 +253,10 @@ module Inferno
           ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{raw_path}.extension" }
             .map { |ex| ex[:url] }
 
-          value_found = find_a_value_at(resource, path) do |potential_value|
-            matching_without_extensions?(potential_value, ms_extension_urls, element_definition[:fixed_value])
-          end
+          value_found =
+            find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |potential_value|
+              matching_without_extensions?(potential_value, ms_extension_urls, element_definition[:fixed_value])
+            end
 
           # Note that false.present? => false, which is why we need to add this extra check
           value_found.present? || value_found == false
@@ -369,7 +380,7 @@ module Inferno
           # TODO: there is a lot of similarity
           # between this and FHIRResourceNavigation.matching_slice?
           # Can these be combined?
-          find_a_value_at(resource, path) do |element|
+          find_a_value_at(resource, path, recursive_segments: recursive_element_segments) do |element|
             case discriminator[:type]
             when 'patternCodeableConcept'
               find_pattern_codeable_concept_slice(element, discriminator)

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -24,16 +24,49 @@ module Inferno
         self.requirement_extension_url = requirement_extension_url
       end
 
+      # @return [String] the canonical URL of the profile
+      def profile_url
+        profile.url
+      end
+
+      # @return [String] the human-readable name of the profile, eg for display purposes.
+      #   Collapses any runs of repeated whitespace, since profile titles occasionally have them.
+      def profile_name
+        profile.title&.squeeze(' ')
+      end
+
+      # @return [String] the version of the profile itself (distinct from the IG's own version)
+      def profile_version
+        profile.version
+      end
+
       # Retrieval method for the must support metadata
       # @return [Hash]
       def must_supports
         @must_supports ||= {
           extensions: must_support_extensions,
           slices: must_support_slices,
-          elements: must_support_elements
+          elements: must_support_elements,
+          recursive_elements: recursive_element_segments
         }
       end
 
+      # Names of path segments that are self-referential, ie, they may repeat at
+      # arbitrary depth. FHIR marks this with a `contentReference` back to an
+      # ancestor element instead of re-declaring the element's children, eg,
+      # Questionnaire.item.item has a contentReference of "#Questionnaire.item".
+      # A MustSupport flag on an element under such a segment (eg Questionnaire.item.text)
+      # should be considered met if it's populated at any depth of nesting
+      # (item.text, item.item.text, item.item.item.text, ...), not just the literal depth
+      # at which the flag is declared. NOTE: does not currently handle sliced recursive elements.
+      # @return [Array<String>]
+      def recursive_element_segments
+        profile_elements
+          .select { |element| element.contentReference.present? }
+          .map { |element| element.id.split('.').last }
+          .uniq
+      end
+
       def by_requirement_extension_only?(element)
         requirement_extension_url && !element.mustSupport &&
           element.extension.any? do |extension|
@@ -53,6 +86,7 @@ module Inferno
         must_support_extension_elements.map do |element|
           {
             id: element.id,
+            slice_name: extension_slice_name(element.id),
             path: element.path.gsub("#{resource}.", ''),
             url: canonical_url_without_version(element.type.first.profile.first),
             modifier_extension: element.path.end_with?('modifierExtension')
@@ -62,6 +96,15 @@ module Inferno
         end
       end
 
+      # The name of the deepest slice in a FHIR ElementDefinition id, eg "us-core-race" for
+      # "Patient.extension:us-core-race" or "ombCategory" for
+      # "Patient.extension:us-core-race.extension:ombCategory".
+      # @param element_id [String]
+      # @return [String, nil]
+      def extension_slice_name(element_id)
+        element_id.split('.').reverse.find { |segment| segment.include?(':') }&.split(':', 2)&.last
+      end
+
       def canonical_url_without_version(url)
         url&.split('|')&.first
       end

data/lib/inferno/dsl/profile_metadata.rb

@@ -0,0 +1,113 @@
+module Inferno
+  module DSL
+    # A ProfileMetadata object is a small, inheritable data holder for generated metadata about a
+    # profile or a group of tests -- most notably the Must Support metadata consumed by
+    # {MustSupportAssessment#missing_must_support_elements} and
+    # {Assertions#assert_must_support_elements_present} via their `metadata:` argument, alongside
+    # whatever other generated metadata a test kit needs to carry around (searches, bindings,
+    # references, etc).
+    #
+    # It exists so that test kits don't need to reach for `OpenStruct` (which accepts any attribute
+    # silently, making typos and generator/consumer drift hard to catch) or hand-roll their own
+    # version of this exact pattern.
+    #
+    # Test kits define a subclass and declare whatever attributes they need with `.attribute`.
+    # `must_supports` is always available, since it's the attribute Inferno's Must Support logic
+    # reads:
+    #
+    #   class GroupMetadata < Inferno::DSL::ProfileMetadata
+    #     attribute :searches
+    #     attribute :bindings
+    #   end
+    #
+    #   metadata = GroupMetadata.from_file('path/to/generated/metadata.yml')
+    #   metadata.must_supports #=> { elements: [...], extensions: [...], slices: [...] }
+    #
+    # @see MustSupportAssessment#missing_must_support_elements
+    class ProfileMetadata
+      class << self
+        # The full list of attribute names declared on this class and its ancestors.
+        # @return [Array<Symbol>]
+        def attribute_names
+          @attribute_names ||= superclass.respond_to?(:attribute_names) ? superclass.attribute_names.dup : []
+        end
+
+        # Declare an attribute that instances of this class (and subclasses) may be initialized with.
+        # @param name [Symbol]
+        # @return [void]
+        def attribute(name)
+          name = name.to_sym
+          attribute_names << name unless attribute_names.include?(name)
+          attr_accessor name
+        end
+
+        # Build an instance from a YAML file, eg one written by a metadata generator.
+        # @param path [String, Pathname]
+        # @return [ProfileMetadata]
+        def from_file(path)
+          new(YAML.load_file(path, aliases: true))
+        end
+      end
+
+      # Profile identity, mirroring fields read directly off the FHIR StructureDefinition
+      # (`resource` is the resource type the profile constrains, ie `profile.type`).
+      attribute :resource
+      attribute :profile_url
+      attribute :profile_name
+      attribute :profile_version
+
+      attribute :must_supports
+
+      # @param metadata [Hash] a hash of attribute name/value pairs. Keys not declared with
+      #   `.attribute` raise an error, so that a mismatch between a metadata generator and this
+      #   class's declared attributes is caught immediately rather than silently ignored.
+      def initialize(metadata = {})
+        metadata.each do |key, value|
+          key = key.to_sym
+          raise "Unknown #{self.class} attribute: #{key}" unless self.class.attribute_names.include?(key)
+
+          public_send(:"#{key}=", value)
+        end
+
+        self.must_supports ||= {}
+      end
+
+      # @return [Hash] the declared attributes and their current values, omitting unset (nil) ones
+      def to_hash
+        self.class.attribute_names.each_with_object({}) do |name, hash|
+          value = public_send(name)
+          hash[name] = value unless value.nil?
+        end
+      end
+
+      # Every Must Support element, slice, and extension in `must_supports`, each represented as a
+      # single string and sorted alphabetically. Unlike the list returned by a missing-elements
+      # 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"`).
+      # @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 + 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/resume_test_route.rb

@@ -84,7 +84,10 @@ module Inferno
 
         test_run = find_test_run(test_run_identifier)
 
-        halt 500, "Unable to find test run with identifier '#{test_run_identifier}'." if test_run.nil?
+        if test_run.nil?
+          halt 500, "Unable to find test run with identifier '#{test_run_identifier}' " \
+                    "on request to '#{request.url}'."
+        end
 
         test_runs_repo.mark_as_no_longer_waiting(test_run.id)