inferno_core 1.4.6 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed690c6df4e1cfcb7f4ec361fb8326af28107839c20fbb9de6069ccdc3e950b
-  data.tar.gz: 1c35c4afdf97fc1f8e053d213bdc643099c79defd0b09e50fccb34977a2a497d
+  metadata.gz: ebcc6f348889f26a45097656da0a40a89b233bc7a216f06c8d538092362419a1
+  data.tar.gz: dfddeba814ef81eaddbc3b54635903cc01b9a7016a00a06eb6c723a01af2adf7
 SHA512:
-  metadata.gz: '048ca08826b17e50cbbd7452d600e996287167ec72d7993ed3a7686849bc6bbcd61221138df2dd5520ee9156deda55c8d577d99f9ade542d17cda31857d82837'
-  data.tar.gz: b1878c6aedf0f99732536a02fad0cbc2cf2913d21e8cae56586764a04c428346303fd9fb95c462538a96a3968fee7cac3cb0e27bd8b28998e293597aa94d7fd9
+  metadata.gz: b97797a253c6d9419ce3a715e56a97464a4ce04f0e48944067c9fbe72b1c645c907d11c33cca7cbe5bfa2771f25908dfdd7ead1f59d63ef5f0850755d2733ce4
+  data.tar.gz: '0184d977bbb3e25ef6ef3d9b02ec69e7f17f90cec4f00b54b19e3eab87a5621bec611d3fd2b9a20079503e873ec1141999c1df357d4cb0937da48c36d5a05814'

data/lib/inferno/apps/web/serializers/test.rb

@@ -23,6 +23,7 @@ module Inferno
         field :optional?, name: :optional
         field :simulation_verification?, name: :is_simulation_verification
         field :attestation?, name: :is_attestation
+        field :tester_initiated_exchange?, name: :is_tester_initiated_exchange
         field :verifies_requirements, if: :field_present?, extractor: RequirementsFilteringExtractor
       end
     end

data/lib/inferno/apps/web/serializers/test_group.rb

@@ -18,6 +18,7 @@ module Inferno
         field :user_runnable?, name: :user_runnable
         field :optional?, name: :optional
         field :simulation_verification?, name: :is_simulation_verification
+        field :tester_initiated_exchange?, name: :is_tester_initiated_exchange
 
         field :test_count do |group, options|
           group.test_count(options[:suite_options])

data/lib/inferno/apps/web/templates/test_kit.html.erb

@@ -145,11 +145,15 @@
               </div>
               <div class="modal-body">
                 <p>
-                  Test Kits are broadly grouped into three levels of maturity:
-                  <strong>High</strong>, <strong>Moderate</strong>, and
-                  <strong>Low</strong>.  This is intended to provide guidance to users
-                  on the level of confidence they should place in the accuracy and
-                  completeness of these tests.
+                  Test Kits are broadly grouped into four levels of maturity:
+                  <strong>Certification</strong>, <strong>High</strong>,
+                  <strong>Medium</strong>, and <strong>Low</strong>.  This is intended
+                  to provide guidance to users on the level of confidence they should
+                  place in the accuracy and completeness of these tests.
+                </p>
+                <p>
+                  <strong>Certification</strong> maturity Test Kits are used as part
+                  of a formal certification program.
                 </p>
                 <p>
                   <strong>High</strong> maturity Test Kits typically have been
@@ -157,7 +161,7 @@
                   that has limited ambiguity.
                 </p>
                 <p>
-                  <strong>Moderate</strong> and <strong>Low</strong> maturity Test Kits typically have
+                  <strong>Medium</strong> and <strong>Low</strong> maturity Test Kits typically have
                   not had widespread usage and/or are targeting less mature
                   specifications that contain ambiguous or conflicting information.
                   These Test Kits are still of value to implementers, but they should be

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]
@@ -195,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
@@ -452,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/resume_test_route.rb

@@ -75,6 +75,17 @@ module Inferno
         test_run.test_suite_id || test_run.test_group_id || test.parent&.id || test.id
       end
 
+      # @private
+      def no_test_run_message(test_run_identifier, url)
+        base_message = "Inferno could not find an active test run for this request to '#{url}'"
+
+        if test_run_identifier.blank?
+          "#{base_message}: no identifier found."
+        else
+          "#{base_message}: identifier '#{test_run_identifier}' is not associated with a waiting session."
+        end
+      end
+
       # @private
       def handle(req, res)
         request = Inferno::Entities::Request.from_hanami_request(req)
@@ -84,10 +95,7 @@ module Inferno
 
         test_run = find_test_run(test_run_identifier)
 
-        if test_run.nil?
-          halt 500, "Unable to find test run with identifier '#{test_run_identifier}' " \
-                    "on request to '#{request.url}'."
-        end
+        halt 500, no_test_run_message(test_run_identifier, request.url) if test_run.nil?
 
         test_runs_repo.mark_as_no_longer_waiting(test_run.id)
 

data/lib/inferno/dsl/runnable.rb

@@ -309,14 +309,17 @@ module Inferno
         !optional?
       end
 
-      # Mark as simulation verification. Tests are not simulation verification by default.
+      # Flag as simulation verification. Tests are not simulation verification by default.
       #
       # @param simulation_verification [Boolean]
       # @return [void]
-      def simulation_verification(simulation_verification = true) # rubocop:disable Style/OptionalBooleanParameter
+      def flag_as_simulation_verification(simulation_verification = true) # rubocop:disable Style/OptionalBooleanParameter
         @is_simulation_verification = simulation_verification
       end
 
+      # Alias for {#flag_as_simulation_verification}
+      alias simulation_verification flag_as_simulation_verification
+
       # The test is simulation verification if true
       #
       # @return [Boolean]
@@ -324,14 +327,17 @@ module Inferno
         !!@is_simulation_verification
       end
 
-      # Mark as attestation. Tests are not attestation by default.
+      # Flag as attestation. Tests are not attestation by default.
       #
       # @param attestation [Boolean]
       # @return [void]
-      def attestation(attestation = true) # rubocop:disable Style/OptionalBooleanParameter
+      def flag_as_attestation(attestation = true) # rubocop:disable Style/OptionalBooleanParameter
         @is_attestation = attestation
       end
 
+      # Alias for {#flag_as_attestation}
+      alias attestation flag_as_attestation
+
       # The test is attestation if true
       #
       # @return [Boolean]
@@ -339,6 +345,21 @@ module Inferno
         !!@is_attestation
       end
 
+      # Flag as tester-initiated exchange. Tests are not tester-initiated exchanges by default.
+      #
+      # @param tester_initiated_exchange [Boolean]
+      # @return [void]
+      def flag_as_tester_initiated_exchange(tester_initiated_exchange = true) # rubocop:disable Style/OptionalBooleanParameter
+        @is_tester_initiated_exchange = tester_initiated_exchange
+      end
+
+      # The test is a tester-initiated exchange if true
+      #
+      # @return [Boolean]
+      def tester_initiated_exchange?
+        !!@is_tester_initiated_exchange
+      end
+
       # @private
       def default_id
         to_s

data/lib/inferno/dsl/suite_endpoint.rb

@@ -97,7 +97,9 @@ module Inferno
 
         # @private
         def error_response_format_value
-          @error_response_format_value ||= :text
+          return @error_response_format_value if @error_response_format_value.present?
+
+          superclass.respond_to?(:error_response_format_value) ? superclass.error_response_format_value : :text
         end
       end
 
@@ -308,7 +310,8 @@ module Inferno
         log_error(e)
         render_error_and_halt do
           error_response(
-            'An error occurred while determining the test run identifier for this request.',
+            "Inferno could not find an active test run for this request to '#{request.url}': " \
+            'error encountered while determining the test run identifier.',
             code: 'exception',
             diagnostics: e.full_message
           )
@@ -317,7 +320,7 @@ module Inferno
 
       # @private
       def no_session_message
-        base_message = "Unable to find test run for request to '#{request.url}'"
+        base_message = "Inferno could not find an active test run for this request to '#{request.url}'"
         location = test_run_identifier_location_description
         identifier = find_test_run_identifier
 
@@ -369,10 +372,11 @@ module Inferno
           details: FHIR::CodeableConcept.new(text: message)
         )
         issue.diagnostics = diagnostics if diagnostics
+        meta = FHIR::Meta.new(source: Application['base_url'])
 
         response.status = 500
         response.content_type = 'application/fhir+json'
-        response.body = FHIR::OperationOutcome.new(issue: [issue]).to_json
+        response.body = FHIR::OperationOutcome.new(meta:, issue: [issue]).to_json
       end
 
       # @private
@@ -427,7 +431,7 @@ module Inferno
         log_error(e)
         render_error_and_halt do
           error_response(
-            'An error occurred while processing this request.',
+            "Inferno encountered an error while processing this request to '#{request.url}'.",
             code: 'exception',
             diagnostics: e.full_message
           )
@@ -459,7 +463,7 @@ module Inferno
 
           response_headers = response_headers.map { |name, value| { name:, value: } }
 
-          repo.create(
+          persisted_request = repo.create(
             verb:,
             url:,
             direction: 'incoming',
@@ -474,6 +478,15 @@ module Inferno
             tags: env['inferno.tags']
           )
 
+          # Display the request with the waiting test's result. Failures are
+          # logged rather than raised so that they cannot prevent the test run
+          # from resuming.
+          begin
+            results_repo.add_request(env['inferno.result_id'], persisted_request.id)
+          rescue StandardError => e
+            log_error(e, url:)
+          end
+
           if env['inferno.resume_test_run']
             test_run_id = env['inferno.test_run_id']
             Inferno::Repositories::TestRuns.new.mark_as_no_longer_waiting(test_run_id)

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

@@ -92,7 +92,8 @@ module Inferno
 
         # Set/get the maturity level for the test kit
         #
-        # @param new_maturity [String]
+        # @param new_maturity [String] one of 'Low', 'Medium', 'High', or
+        #   'Certification'
         # @return [String]
         def maturity(new_maturity = nil)
           return @maturity if new_maturity.nil?