ipa_test_kit 0.2.0 → 0.3.1

data/lib/ipa_test_kit/must_support_test.rb

@@ -14,7 +14,13 @@ module IpaTestKit
     def perform_must_support_test(resources)
       skip_if resources.blank?, "No #{resource_type} resources were found"
 
-      if (missing_elements(resources) + missing_slices(resources)).length.zero?
+      missing_elements(resources)
+      missing_slices(resources)
+      missing_extensions(resources)
+
+      handle_must_support_choices if metadata.must_supports[:choices].present?
+
+      if (missing_elements + missing_slices + missing_extensions).length.zero?
         pass
       end
 
@@ -22,6 +28,32 @@ module IpaTestKit
            "provided #{resource_type} resource(s)"
     end
 
+    def handle_must_support_choices
+      missing_elements.delete_if do |element|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_extensions.delete_if do |extension|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_slices.delete_if do |slice|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
+        is_any_choice_supported?(choices)
+      end
+    end
+
+    def is_any_choice_supported? (choices)
+      choices.present? &&
+      (
+        choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
+        choices[:extension_ids]&.any? { |extension_id| missing_extensions.none? { |extension| extension[:id] == extension_id} } ||
+        choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name} }
+      )
+    end
+
     def missing_must_support_strings
       missing_elements.map { |element_definition| missing_element_string(element_definition) } +
         missing_slices.map { |slice_definition| slice_definition[:name] } +
@@ -64,12 +96,15 @@ module IpaTestKit
 
               (value_without_extensions.present? || value_without_extensions == false) &&
                 (element_definition[:fixed_value].blank? || value == 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
         end
+
+      @missing_elements
     end
 
     def must_support_slices
@@ -94,6 +129,11 @@ module IpaTestKit
           find_a_value_at(element, coding_path) do |coding|
             coding.code == discriminator[:code] && coding.system == discriminator[:system]
           end
+        when 'patternCoding'
+          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
         when 'patternIdentifier'
           find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
         when 'value'
@@ -107,11 +147,20 @@ module IpaTestKit
             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
+        when 'requiredBinding'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) {|coding| discriminator[:values].include?(coding.code) }
         end
       end
     end

data/lib/ipa_test_kit/provenance_validator.rb

@@ -0,0 +1,38 @@
+require_relative 'fhir_resource_navigation'
+
+module IpaTestKit
+  class ProvenanceValidator
+    include FHIRResourceNavigation
+
+    def self.validate(...)
+      new(...).validate
+    end
+
+    attr_reader :resource, :validation_messages
+
+    def initialize(resource)
+      @resource = resource
+      @validation_messages = []
+    end
+
+    def validate
+      # Invariant provenance-1 in US Core 5 causes validation error. See FHIR-39518
+      return validation_messages unless resource.instance_of?(FHIR::Provenance)
+
+      failed_provenance =
+        find_a_value_at(resource, 'agent') do |agent|
+          ['Practitioner', 'Device'].any? { |resource_type| agent.who.reference&.include?(resource_type) } &&
+          agent.onBehalfOf.nil?
+        end
+
+      if failed_provenance.present?
+        validation_messages << {
+          type: 'error',
+          message: "#{resource.resourceType}/#{resource.id}: Rule provenance-1: 'onBehalfOf SHALL be present when Provenance.agent.who is a Practitioner or Device' Failed"
+        }
+      end
+
+      validation_messages
+    end
+  end
+end

data/lib/ipa_test_kit/read_test.rb

@@ -52,7 +52,7 @@ module IpaTestKit
     end
 
     def bad_resource_id_message(expected_id)
-      "Expected resource to have id: `#{id}`, but found `#{resource.id}`"
+      "Expected resource to have id: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
     end
 
     def resource_class

data/lib/ipa_test_kit/reference_resolution_test.rb

@@ -1,41 +1,55 @@
-require_relative '../ipa_test_kit/generated/resource_list'
+require_relative 'fhir_resource_navigation'
 
 module IpaTestKit
   module ReferenceResolutionTest
-    include ResourceList
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
 
     def perform_reference_resolution_test(resources)
       skip_if resources.blank?, no_resources_skip_message
 
-      self.resolution_count = 0
-
-      resources.each do |resource|
-        break if resolution_count >= max_resolutions
-
-        validate_reference_resolutions(resource)
-      end
-
-      messages.uniq!
-      errors_found = messages.any? { |message| message[:type] == 'error' }
+      pass if unresolved_references(resources).length.zero?
 
-      assert !errors_found, "Inferno was unable to resolve all IPA references"
+      skip "Could not resolve Must Support references #{unresolved_references_strings.join(', ')}"
     end
 
-    def max_resolutions
-      50
+    def unresolved_references_strings
+      unresolved_reference_hash =
+        unresolved_references.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |missing, hash|
+          hash[missing[:path]] << missing[:target_profile]
+        end
+      unresolved_reference_hash.map { |path, profiles| "#{path}#{"(#{profiles.join('|')})" unless profiles.first.empty?}" }
     end
 
-    def resolution_count
-      @resolution_count
-    end
+    def record_resolved_reference(reference, target_profile)
+      saved_reference = resolved_references.find { |item| item[:reference] == reference.reference }
 
-    def resolution_count=(count)
-      @resolution_count = count
+      if saved_reference.present?
+        if target_profile.present? && !saved_reference[:profiles].include?(target_profile)
+          saved_reference[:profiles] << target_profile
+        end
+      else
+        saved_reference = {
+          reference: reference.reference,
+          profiles: []
+        }
+
+        saved_reference[:profiles] << target_profile if target_profile.present?
+        resolved_references.add(saved_reference)
+      end
     end
 
-    def record_resolved_reference(reference)
-      self.resolution_count += 1
-      resolved_references.add?(reference.reference)
+    def is_reference_resolved?(reference, target_profile)
+      resolved_references.any? do |item|
+        next unless item[:reference].is_a? FHIR::Reference
+
+        item[:reference] == reference.reference &&
+        (
+          target_profile.blank? || item[:profiles].include?(target_profile)
+        )
+      end
     end
 
     def resolved_references
@@ -47,65 +61,120 @@ module IpaTestKit
       'Please use patients with more information.'
     end
 
-    def validate_reference_resolutions(resource)
-      problems = []
+    def must_support_references
+      metadata.must_supports[:elements].select { |element_definition| element_definition[:types]&.include?('Reference') }
+    end
+
+    def must_support_references_with_target_profile
+      # mapping array of target_profiles to array of {path, target_profile} pair
+      must_support_references.map do |element_definition|
+        (element_definition[:target_profiles] || ['']).map do |target_profile|
+          {
+            path: element_definition[:path],
+            target_profile: target_profile
+          }
+        end
+      end.flatten
+    end
+
+    def unresolved_references(resources = [])
+      @unresolved_references ||=
+        must_support_references_with_target_profile.select do |reference_path_profile_pair|
+          path = reference_path_profile_pair[:path]
+          target_profile = reference_path_profile_pair[:target_profile]
 
-      resource.each_element do |reference, meta, path|
-        next if meta['type'] != 'Reference'
-        next if reference.reference.blank?
-        next if resolved_references.include?(reference.reference)
-        break if resolution_count >= max_resolutions
+          found_one_reference = false
 
-        if reference.contained?
-          # if reference_id is blank it is referring to itself, so we know it exists
-          next if reference.reference_id.blank?
+          resolve_one_reference = resources.any? do |resource|
+            value_found = resolve_path(resource, path)
+            next if value_found.empty?
 
-          unless resource.contained.any? { |contained_resource| contained_resource&.id == reference.reference_id }
-            messages << {
-              type: 'error',
-              message: "#{path} has contained reference to id '#{reference.reference_id}' that does not exist"
-            }
+            found_one_reference = true
+
+            value_found.any? do |reference|
+              validate_reference_resolution(resource, reference, target_profile)
+            end
           end
 
-          next
+          found_one_reference && !resolve_one_reference
         end
 
-        # Should potentially update valid? method in fhir_dstu2_models
-        # to check for this type of thing
-        # e.g. "patient/54520" is invalid (fhir_client resource_class method would expect "Patient/54520")
-        if reference.relative?
-          begin
-            reference.resource_class
-          rescue NameError
-            problems << "#{path} has invalid resource type in reference: #{reference.type}"
-            next
-          end
+      if metadata.must_supports[:choices].present?
+        @unresolved_references.delete_if do |reference|
+          choice_profiles = metadata.must_supports[:choices].find { |choice| choice[:target_profiles]&.include?(reference[:target_profile]) }
+
+          choice_profiles.present? &&
+          choice_profiles[:target_profiles]&.any? { |profile| @unresolved_references.none? { |element| element[:target_profile] == profile } }
         end
-        reference_type = reference.resource_type
+      end
 
+      @unresolved_references
+    end
+
+    def validate_reference_resolution(resource, reference, target_profile)
+      return false unless reference.is_a? FHIR::Reference
+      return true if is_reference_resolved?(reference, target_profile)
+
+      if reference.contained?
+        # if reference_id is blank it is referring to itself, so we know it exists
+        return true if reference.reference_id.blank?
+
+        return resource.contained.any? do |contained_resource|
+            contained_resource&.id == reference.reference_id &&
+              resource_is_valid_with_target_profile?(contained_resource, target_profile)
+          end
+      end
+
+      reference_type = reference.resource_type
+      reference_id = reference.reference_id
+
+      resolved_resource =
         begin
-          # TODO: this request isn't persisted
-          resolved_resource = reference.read(fhir_client)
-        rescue ClientException => e
-          # report error if the resource is a IPA resource type
-          messages << {
-            type: 'error',
-            message: "#{path} did not resolve: #{e}"
-          } if RESOURCE_LIST.include?(reference_type)
-
-          next
+          if reference.relative?
+            begin
+              reference.resource_class
+            rescue NameError
+              return false
+            end
+
+            fhir_read(reference_type, reference_id)&.resource
+          else
+            if reference.base_uri.chomp('/') == fhir_client.instance_variable_get(:@base_service_url).chomp('/')
+              fhir_read(reference_type, reference_id)&.resource
+            else
+              get(reference.reference)&.resource
+            end
+          end
+        rescue StandardError => e
+          Inferno::Application['logger'].error("Unable to resolve reference #{reference.reference}")
+          Inferno::Application['logger'].error(e.full_message)
+          return false
         end
 
-        if resolved_resource&.resourceType == reference_type
-          record_resolved_reference(reference)
-        else
-          messages << {
-            type: 'error',
-            message: "Expected #{reference.reference} to refer to a #{reference_type} resource, " \
-                     "but found a #{resolved_resource&.resourceType} resource."
-          }
-        end
-      end
+      return false unless resolved_resource&.resourceType == reference_type && resolved_resource&.id == reference_id
+
+      return false unless resource_is_valid_with_target_profile?(resolved_resource, target_profile)
+
+      record_resolved_reference(reference, target_profile)
+      true
+    end
+
+    def resource_is_valid_with_target_profile?(resource, target_profile)
+      return true if target_profile.blank?
+
+      # Only need to know if the resource is valid.
+      # Calling resource_is_valid? causes validation errors to be logged.
+      validator = find_validator(:default)
+
+      outcome = FHIR::OperationOutcome.new(JSON.parse(validator.validate(resource, target_profile)))
+
+      message_hashes = outcome.issue&.map { |issue| validator.message_hash_from_issue(issue, resource) } || []
+
+      message_hashes.concat(validator.additional_validation_messages(resource, target_profile))
+
+      validator.filter_messages(message_hashes)
+
+      message_hashes.none? { |message_hash| message_hash[:type] == 'error' }
     end
   end
 end