inferno_core 0.6.4 → 0.6.5

data/lib/inferno/dsl/fhir_resource_validation.rb

@@ -9,7 +9,7 @@ module Inferno
     #
     # @example
     #
-    #   validator do
+    #   fhir_resource_validator do
     #     url 'http://example.com/validator'
     #     exclude_message { |message| message.type == 'info' }
     #     perform_additional_validation do |resource, profile_url|
@@ -19,12 +19,24 @@ module Inferno
     #         { type: 'info', message: 'everything is ok' }
     #       end
     #     end
+    #     cli_context do
+    #       noExtensibleBindingMessages true
+    #       allowExampleUrls true
+    #       txServer nil
+    #     end
     #   end
     module FHIRResourceValidation
       def self.included(klass)
         klass.extend ClassMethods
       end
 
+      # Find a particular profile StructureDefinition and the IG it belongs to.
+      # Looks through a runnable's parents up to the suite to find a validator with a particular name,
+      # then finds the profile by looking through its defined igs.
+      def find_ig_and_profile(profile_url, validator_name)
+        self.class.find_ig_and_profile(profile_url, validator_name)
+      end
+
       class Validator
         attr_reader :requirements
         attr_accessor :session_id, :name, :test_suite_id
@@ -62,7 +74,7 @@ module Inferno
         #   igs("hl7.fhir.us.core#3.1.1", "hl7.fhir.us.core#6.0.0")
         # @param validator_igs [Array<String>]
         def igs(*validator_igs)
-          cli_context(igs: validator_igs) if validator_igs
+          cli_context(igs: validator_igs) if validator_igs.any?
 
           cli_context.igs
         end
@@ -193,8 +205,14 @@ module Inferno
                 'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
         end
 
+        # @private
+        def exclude_unresolved_url_message
+          proc { |message| message.message.match?(/\A\S+: [^:]+: URL value '.*' does not resolve/) }
+        end
+
         # @private
         def filter_messages(message_hashes)
+          message_hashes.reject! { |message| exclude_unresolved_url_message.call(Entities::Message.new(message)) }
           message_hashes.reject! { |message| exclude_message.call(Entities::Message.new(message)) } if exclude_message
         end
 
@@ -392,6 +410,20 @@ module Inferno
 
           fhir_validators[name] = current_validators
         end
+
+        # @private
+        def find_ig_and_profile(profile_url, validator_name)
+          validator = find_validator(validator_name)
+          if validator.is_a? Inferno::DSL::FHIRResourceValidation::Validator
+            validator.igs.each do |ig_id|
+              ig = Inferno::Repositories::IGs.new.find_or_load(ig_id)
+              profile = ig.profile_by_url(profile_url)
+              return ig, profile if profile
+            end
+          end
+
+          raise "Unable to find profile #{profile_url} in any IG defined for validator #{validator_name}"
+        end
       end
     end
   end

data/lib/inferno/dsl/fhir_validation.rb

@@ -7,6 +7,7 @@ module Inferno
     # `assert_valid_resource` for validation rather than directly calling
     # methods on a validator.
     #
+    # @deprecated Use {Inferno::DSL::FHIRResourceValidation} instead
     # @example
     #
     #   validator do
@@ -152,8 +153,14 @@ module Inferno
                 'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
         end
 
+        # @private
+        def exclude_unresolved_url_message
+          proc { |message| message.message.match?(/\A\S+: [^:]+: URL value '.*' does not resolve/) }
+        end
+
         # @private
         def filter_messages(message_hashes)
+          message_hashes.reject! { |message| exclude_unresolved_url_message.call(Entities::Message.new(message)) }
           message_hashes.reject! { |message| exclude_message.call(Entities::Message.new(message)) } if exclude_message
         end
 
@@ -243,6 +250,8 @@ module Inferno
         end
 
         # Define a validator
+        # @deprecated Use
+        #   {Inferno::DSL::FHIRResourceValidation::ClassMethods#fhir_resource_validator} instead
         # @example
         #   validator do
         #     url 'http://example.com/validator'
@@ -261,6 +270,10 @@ module Inferno
         # @param required_suite_options [Hash] suite options that must be
         #   selected in order to use this validator
         def validator(name = :default, required_suite_options: nil, &)
+          Inferno::Application['logger'].warn(
+            "'validator' in '#{suite.id}' TestSuite is deprecated and will be removed in an upcoming release. " \
+            "Use 'fhir_resource_validator' instead."
+          )
           current_validators = fhir_validators[name] || []
 
           new_validator = Inferno::DSL::FHIRValidation::Validator.new(required_suite_options, &)

data/lib/inferno/dsl/must_support_assessment.rb

@@ -0,0 +1,365 @@
+module Inferno
+  module DSL
+    # The MustSupportAssessment module contains the logic for tests
+    # that check "All Must Support elements are present".
+    # Generally, test authors should use `assert_must_support_elements_present`
+    # or `missing_must_support_elements` DSL methods.
+    # A few additional methods are exposed to support the transition of existing tests that
+    # call into these methods directly.
+    module MustSupportAssessment
+      # Find any Must Support elements defined on the given profile that are missing in the given resources.
+      # Must Support elements are identified on the profile StructureDefinition and pre-parsed into metadata,
+      # which may be customized prior to the check by passing a block. Alternate metadata may be provided directly.
+      # Set test suite config flag debug_must_support_metadata: true to log the metadata to a file for debugging.
+      #
+      # @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 requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
+      # @yield [Metadata] 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, &)
+        debug_metadata = config.options[:debug_must_support_metadata]
+
+        if metadata.present?
+          InternalMustSupportLogic.new.perform_must_support_test_with_metadata(resources, metadata, debug_metadata:)
+        else
+          ig, profile = find_ig_and_profile(profile_url, validator_name)
+          perform_must_support_assessment(profile, resources, ig, debug_metadata:, requirement_extension:, &)
+        end
+      end
+
+      # perform_must_support_assessment allows customizing the metadata with a block.
+      # Customizing the metadata may add, modify, or remove items.
+      # For instance, US Core 3.1.1 Patient "Previous Name" is defined as MS only in narrative.
+      # Choices are also defined only in narrative.
+      # @param profile [FHIR::StructureDefinition]
+      # @param resources [Array<FHIR::Model>]
+      # @param ig [Inferno::Entities::IG]
+      # @param debug_metadata [Boolean] if true, write out the final metadata used to a temporary file
+      # @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
+      # @return [Array<String>] list of elements that were not found in the provided resources
+      def perform_must_support_assessment(profile, resources, ig, debug_metadata: false, requirement_extension: nil)
+        test_impl = InternalMustSupportLogic.new
+        profile_metadata = test_impl.extract_metadata(profile, ig, requirement_extension:)
+        yield profile_metadata if block_given?
+
+        test_impl.perform_must_support_test_with_metadata(resources, profile_metadata, debug_metadata:)
+      end
+
+      def find_missing_elements(resources, must_support_elements)
+        InternalMustSupportLogic.new(metadata).find_missing_elements(resources, must_support_elements)
+      end
+
+      def missing_element_string(element_definition)
+        InternalMustSupportLogic.new.missing_element_string(element_definition)
+      end
+
+      # @private
+      class InternalMustSupportLogic
+        include FHIRResourceNavigation
+
+        attr_accessor :metadata
+
+        def initialize(metadata = nil)
+          @metadata = metadata
+        end
+
+        # perform_must_support_test_with_metadata is invoked from check and perform_must_support_test,
+        # with the metadata to be used as the basis for the test.
+        # It may also be invoked directly from a test if you want to completely overwrite the metadata.
+        # @param resources [Array<FHIR::Model>]
+        # @param profile_metadata [Metadata] Metadata object with must_supports field
+        # @param debug_metadata [Boolean] if true, write out the final metadata used to a temporary file
+        # @return [Array<String>] list of elements that were not found in the provided resources
+        def perform_must_support_test_with_metadata(resources, profile_metadata, debug_metadata: false)
+          return if resources.blank?
+
+          @metadata = profile_metadata
+
+          write_metadata_for_debugging if debug_metadata
+
+          perform_test(resources)
+        end
+
+        def extract_metadata(profile, ig, requirement_extension: nil)
+          MustSupportMetadataExtractor.new(profile.snapshot.element, profile, profile.type, ig, requirement_extension)
+        end
+
+        def write_metadata_for_debugging
+          outfile = "#{metadata.profile&.id}-#{SecureRandom.uuid}.yml"
+
+          File.open(File.join(Dir.tmpdir, outfile), 'w') do |f|
+            writable_metadata = { must_supports: @metadata.must_supports.to_hash }
+            f.write(YAML.dump(writable_metadata))
+            puts "Wrote MustSupport metadata to #{f.path}"
+          end
+        end
+
+        def perform_test(resources)
+          missing_elements(resources)
+          missing_slices(resources)
+          missing_extensions(resources)
+
+          handle_must_support_choices if metadata.must_supports[:choices].present?
+
+          missing_must_support_strings
+        end
+
+        def handle_must_support_choices
+          handle_must_support_element_choices
+          handle_must_support_extension_choices
+          handle_must_support_slice_choices
+        end
+
+        def handle_must_support_element_choices
+          missing_elements.delete_if do |element|
+            choices = metadata.must_supports[:choices].find do |choice|
+              choice[:paths]&.include?(element[:path]) ||
+                choice[:elements]&.any? { |ms_element| ms_element[:path] == element[:path] }
+            end
+            any_choice_supported?(choices)
+          end
+        end
+
+        def handle_must_support_extension_choices
+          missing_extensions.delete_if do |extension|
+            choices = metadata.must_supports[:choices].find do |choice|
+              choice[:extension_ids]&.include?(extension[:id])
+            end
+            any_choice_supported?(choices)
+          end
+        end
+
+        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]) }
+            any_choice_supported?(choices)
+          end
+        end
+
+        def any_choice_supported?(choices)
+          return false unless choices.present?
+
+          any_path_choice_supported?(choices) ||
+            any_extension_ids_choice_supported?(choices) ||
+            any_slice_names_choice_supported?(choices) ||
+            any_elements_choice_supported?(choices)
+        end
+
+        def any_path_choice_supported?(choices)
+          return false unless choices[:paths].present?
+
+          choices[:paths].any? { |path| missing_elements.none? { |element| element[:path] == path } }
+        end
+
+        def any_extension_ids_choice_supported?(choices)
+          return false unless choices[:extension_ids].present?
+
+          choices[:extension_ids].any? do |extension_id|
+            missing_extensions.none? { |extension| extension[:id] == extension_id }
+          end
+        end
+
+        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 } }
+        end
+
+        def any_elements_choice_supported?(choices)
+          return false unless choices[:elements].present?
+
+          choices[:elements].any? do |choice|
+            missing_elements.none? do |element|
+              element[:path] == choice[:path] && element[:fixed_value] == choice[:fixed_value]
+            end
+          end
+        end
+
+        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] }
+        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
+        end
+
+        def must_support_extensions
+          metadata.must_supports[:extensions]
+        end
+
+        def missing_extensions(resources = [])
+          @missing_extensions ||=
+            must_support_extensions.select do |extension_definition|
+              resources.none? do |resource|
+                path = extension_definition[:path]
+
+                if path == 'extension'
+                  resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+                else
+                  extension = find_a_value_at(resource, path) do |el|
+                    el.url == extension_definition[:url]
+                  end
+
+                  extension.present?
+                end
+              end
+            end
+        end
+
+        def must_support_elements
+          metadata.must_supports[:elements]
+        end
+
+        def missing_elements(resources = [])
+          @missing_elements ||= find_missing_elements(resources, must_support_elements)
+        end
+
+        def find_missing_elements(resources, must_support_elements)
+          must_support_elements.select do |element_definition|
+            resources.none? { |resource| resource_populates_element?(resource, element_definition) }
+          end
+        end
+
+        def resource_populates_element?(resource, element_definition)
+          path = element_definition[:path]
+          ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{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
+
+          # Note that false.present? => false, which is why we need to add this extra check
+          value_found.present? || value_found == false
+        end
+
+        def matching_without_extensions?(value, ms_extension_urls, fixed_value)
+          if value.instance_of?(Inferno::DSL::PrimitiveType)
+            urls = value.extension&.map(&:url)
+            has_ms_extension = (urls & ms_extension_urls).present?
+            value = value.value
+          end
+
+          return false unless has_ms_extension || value_without_extensions?(value)
+
+          matches_fixed_value?(value, fixed_value)
+        end
+
+        def matches_fixed_value?(value, fixed_value)
+          fixed_value.blank? || value == fixed_value
+        end
+
+        def value_without_extensions?(value)
+          value_without_extensions = value.respond_to?(:to_hash) ? value.to_hash.except('extension') : value
+          value_without_extensions.present? || value_without_extensions == false
+        end
+
+        def must_support_slices
+          metadata.must_supports[:slices]
+        end
+
+        def missing_slices(resources = [])
+          @missing_slices ||=
+            must_support_slices.select do |slice|
+              resources.none? do |resource|
+                path = slice[:path]
+                find_slice(resource, path, slice[:discriminator]).present?
+              end
+            end
+        end
+
+        def find_slice(resource, path, discriminator)
+          # 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|
+            case discriminator[:type]
+            when 'patternCodeableConcept'
+              find_pattern_codeable_concept_slice(element, discriminator)
+            when 'patternCoding'
+              find_pattern_coding_slice(element, discriminator)
+            when 'patternIdentifier'
+              find_pattern_identifier_slice(element, discriminator)
+            when 'value'
+              find_value_slice(element, discriminator)
+            when 'type'
+              find_type_slice(element, discriminator)
+            when 'requiredBinding'
+              find_required_binding_slice(element, discriminator)
+            end
+          end
+        end
+
+        def find_pattern_codeable_concept_slice(element, discriminator)
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        end
+
+        def find_pattern_coding_slice(element, discriminator)
+          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        end
+
+        def find_pattern_identifier_slice(element, discriminator)
+          find_a_value_at(element, discriminator[:path]) do |identifier|
+            identifier.system == discriminator[:system]
+          end
+        end
+
+        def find_value_slice(element, discriminator)
+          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+          find_slice_by_values(element, values)
+        end
+
+        def find_type_slice(element, discriminator)
+          case discriminator[:code]
+          when 'Date'
+            begin
+              Date.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'DateTime'
+            begin
+              DateTime.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'String'
+            element.is_a? String
+          else
+            element.is_a? FHIR.const_get(discriminator[:code])
+          end
+        end
+
+        def find_required_binding_slice(element, discriminator)
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+
+          find_a_value_at(element, coding_path) do |coding|
+            discriminator[:values].any? { |value| value[:system] == coding.system && value[:code] == coding.code }
+          end
+        end
+
+        def find_slice_by_values(element, value_definitions)
+          Array.wrap(element).find { |el| verify_slice_by_values(el, value_definitions) }
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/results.rb

@@ -20,12 +20,28 @@ module Inferno
         raise Exceptions::PassException, message if test
       end
 
-      # Halt execution of the current test and mark it as skipped.
+      # Halt execution of the current test and mark it as skipped. This method
+      # can also take a block with an assertion, and if the assertion fails, the
+      # test will skip rather than fail. The message parameter is ignored if a
+      # block is provided.
       #
       # @param message [String]
       # @return [void]
+      #
+      # @example
+      #   if some_precondition_not_met?
+      #     skip('Some precondition was not met.')
+      #   end
+      #
+      #   skip do
+      #     assert false, 'This test will skip rather than fail'
+      #   end
       def skip(message = '')
-        raise Exceptions::SkipException, message
+        raise Exceptions::SkipException, message unless block_given?
+
+        yield
+      rescue Exceptions::AssertionException => e
+        raise Exceptions::SkipException, e.message
       end
 
       # Halt execution of the current test and mark it as skipped if a condition
@@ -38,12 +54,28 @@ module Inferno
         raise Exceptions::SkipException, message if test
       end
 
-      # Halt execution of the current test and mark it as omitted.
+      # Halt execution of the current test and mark it as omitted. This method
+      # can also take a block with an assertion, and if the assertion fails, the
+      # test will omit rather than fail. The message parameter is ignored if a
+      # block is provided.
       #
       # @param message [String]
       # @return [void]
+      #
+      # @example
+      #   if behavior_does_not_need_to_be_tested?
+      #     omit('Behavior does not need to be tested.')
+      #   end
+      #
+      #   omit do
+      #     assert false, 'This test will omit rather than fail'
+      #   end
       def omit(message = '')
-        raise Exceptions::OmitException, message
+        raise Exceptions::OmitException, message unless block_given?
+
+        yield
+      rescue Exceptions::AssertionException => e
+        raise Exceptions::OmitException, e.message
       end
 
       # Halt execution of the current test and mark it as omitted if a condition

data/lib/inferno/dsl/runnable.rb

@@ -81,6 +81,12 @@ module Inferno
         repository.insert(self)
       end
 
+      # @private
+      def remove_self_from_repository
+        repository.remove(self)
+        children.each(&:remove_self_from_repository)
+      end
+
       # An instance of the repository for the class using this module
       # @private
       def repository
@@ -464,6 +470,71 @@ module Inferno
           end
       end
 
+      # Move a child test/group to a new position within the children list.
+      #
+      # @param child_id [Symbol, String] The ID of the child to be moved.
+      # @param new_index [Integer] The new position for the child.
+      # @example
+      #   reorder(:test3, 1) # Moves `test3` to index 1
+      #
+      def reorder(child_id, new_index)
+        index = children.find_index { |child| child.id.to_s.end_with? child_id.to_s }
+        raise Exceptions::RunnableChildNotFoundException.new(child_id, self) unless index
+
+        unless new_index.between?(0, children.length - 1)
+          Inferno::Application[:logger].error <<~ERROR
+            Error trying to reorder children for #{self}:
+            new_index #{new_index} for #{child_id} is out of range
+            (must be between 0 and #{children.length - 1})
+          ERROR
+          return
+        end
+
+        child = children.delete_at(index)
+        children.insert(new_index, child)
+      end
+
+      # Replace a child test/group
+      #
+      # @param id_to_replace [Symbol, String] The ID of the child to be replaced.
+      # @param replacement_id [Symbol, String] The global ID of the group/test that will take the
+      #   place of the child being replaced.
+      # @yield [Inferno::TestGroup, Inferno::Test] Optional block executed in the
+      #    context of the replacement child for additional configuration.
+      # @example
+      #   replace :test2, :test4 do
+      #     id :new_test_id
+      #     config(...)
+      #   end
+      def replace(id_to_replace, replacement_id, &)
+        index = children.find_index { |child| child.id.to_s.end_with? id_to_replace.to_s }
+        raise Exceptions::RunnableChildNotFoundException.new(id_to_replace, self) unless index
+
+        if children[index] < Inferno::TestGroup
+          group(from: replacement_id, &)
+        else
+          test(from: replacement_id, &)
+        end
+
+        remove(id_to_replace)
+        children.insert(index, children.pop)
+      end
+
+      # Remove a child test/group
+      #
+      # @param id_to_remove [Symbol, String]
+      # @example
+      #   test from: :test1
+      #   test from: :test2
+      #   test from: :test3
+      #
+      #   remove :test2
+      def remove(id_to_remove)
+        removed = children.select { |child| child.id.to_s.end_with? id_to_remove.to_s }
+        children.reject! { |child| child.id.to_s.end_with? id_to_remove.to_s }
+        removed.each(&:remove_self_from_repository)
+      end
+
       # @private
       def children(selected_suite_options = [])
         return all_children if selected_suite_options.blank?

data/lib/inferno/dsl.rb

@@ -6,6 +6,7 @@ require_relative 'dsl/fhir_evaluation/evaluator'
 require_relative 'dsl/fhir_resource_validation'
 require_relative 'dsl/fhirpath_evaluation'
 require_relative 'dsl/http_client'
+require_relative 'dsl/must_support_assessment'
 require_relative 'dsl/results'
 require_relative 'dsl/runnable'
 require_relative 'dsl/suite_endpoint'
@@ -23,7 +24,8 @@ module Inferno
       FHIREvaluation,
       FHIRResourceValidation,
       FhirpathEvaluation,
-      Messages
+      Messages,
+      MustSupportAssessment
     ].freeze
 
     EXTENDABLE_DSL_MODULES = [

data/lib/inferno/entities/ig.rb

@@ -15,7 +15,8 @@ module Inferno
       ATTRIBUTES = [
         :id,
         :resources_by_type,
-        :examples
+        :examples,
+        :source_path
       ].freeze
 
       include Inferno::Entities::Attributes
@@ -66,6 +67,7 @@ module Inferno
         end
 
         ig.id = extract_package_id(ig.ig_resource)
+        ig.source_path = ig_path
 
         ig
       end
@@ -89,6 +91,7 @@ module Inferno
         end
 
         ig.id = extract_package_id(ig.ig_resource)
+        ig.source_path = ig_directory
 
         ig
       end

data/lib/inferno/exceptions.rb

@@ -125,5 +125,11 @@ module Inferno
         super("ID '#{id}' already exists. Ensure the uniqueness of the IDs.")
       end
     end
+
+    class RunnableChildNotFoundException < StandardError
+      def initialize(id, runnable)
+        super("Could not find a child with an ID ending in '#{id}' for '#{runnable}'.")
+      end
+    end
   end
 end