us_core_test_kit 0.1.1 → 0.2.0

data/lib/us_core_test_kit/reference_resolution_test.rb

@@ -1,40 +1,29 @@
-require_relative '../us_core_test_kit/generated/resource_list'
+require_relative 'fhir_resource_navigation'
 
 module USCoreTestKit
   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' }
-
-      assert !errors_found, "Inferno was unable to resolve all US Core references"
-    end
-
-    def max_resolutions
-      50
-    end
+      pass if unresolved_references(resources).length.zero?
 
-    def resolution_count
-      @resolution_count
+      skip "Could not resolve Must Support references #{unresolved_references_strings.join(', ')}"
     end
 
-    def resolution_count=(count)
-      @resolution_count = count
+    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 record_resolved_reference(reference)
-      self.resolution_count += 1
       resolved_references.add?(reference.reference)
     end
 
@@ -47,65 +36,96 @@ module USCoreTestKit
       '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
+    end
+
+    def validate_reference_resolution(resource, reference, target_profile)
+      return true if resolved_references.include?(reference.reference) && target_profile.blank?
+
+      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?
 
-        # 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
+        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
+      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 US Core 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)
+      true
+    end
+
+    def resource_is_valid_with_target_profile?(resource, target_profile)
+      return true if target_profile.blank?
+
+      resource_is_valid?(resource: resource, profile_url: target_profile)
     end
   end
 end

data/lib/us_core_test_kit/search_test.rb

@@ -219,8 +219,8 @@ module USCoreTestKit
         next if search_variant_test_records[:comparator_searches].include? name
 
         required_comparators(name).each do |comparator|
-          path = search_param_path(name)
-          date_element = find_a_value_at(scratch_resources_for_patient(patient_id), path)
+          paths = search_param_paths(name).first
+          date_element = find_a_value_at(scratch_resources_for_patient(patient_id), paths)
           params_with_comparator = params.merge(name => date_comparator_value(comparator, date_element))
 
           search_and_check_response(params_with_comparator)
@@ -444,9 +444,13 @@ module USCoreTestKit
       name == 'patient' || (name == '_id' && resource_type == 'Patient')
     end
 
-    def search_param_path(name)
-      path = metadata.search_definitions[name.to_sym][:path]
-      path == 'class' ? 'local_class' : path
+    def search_param_paths(name)
+      paths = metadata.search_definitions[name.to_sym][:paths]
+      if paths.first =='class' 
+        paths[0] = 'local_class'
+      end
+      
+      paths
     end
 
     def all_search_params_present?(params)
@@ -517,52 +521,59 @@ module USCoreTestKit
     end
 
     def search_param_value(name, patient_id, include_system: false)
-      path = search_param_path(name)
-      element = find_a_value_at(scratch_resources_for_patient(patient_id), path)
-      search_value =
-        case element
-        when FHIR::Period
-          if element.start.present?
-            'gt' + (DateTime.xmlschema(element.start) - 1).xmlschema
-          else
-            end_datetime = get_fhir_datetime_range(element.end)[:end]
-            'lt' + (end_datetime + 1).xmlschema
-          end
-        when FHIR::Reference
-          element.reference
-        when FHIR::CodeableConcept
-          if include_system
-            coding =
-              find_a_value_at(element, 'coding') { |coding| coding.code.present? && coding.system.present? }
-            coding.present? ? "#{coding.system}|#{coding.code}" : nil
-          else
-            find_a_value_at(element, 'coding.code')
-          end
-        when FHIR::Identifier
-          if include_system
-            identifier = find_a_value_at(scratch_resources_for_patient(patient_id), path) do |identifier|
-              identifier.value.present? && identifier.system.present?
+      paths = search_param_paths(name)
+      search_value = nil
+      paths.each do |path|
+        element = find_a_value_at(scratch_resources_for_patient(patient_id), path)
+
+        search_value =
+          case element
+          when FHIR::Period
+            if element.start.present?
+              'gt' + (DateTime.xmlschema(element.start) - 1).xmlschema
+            else
+              end_datetime = get_fhir_datetime_range(element.end)[:end]
+              'lt' + (end_datetime + 1).xmlschema
             end
-            identifier.present? ? "#{identifier.system}|#{identifier.value}" : nil
-          else
-            element.value
-          end
-        when FHIR::Coding
-          if include_system
-            coding = find_a_value_at(scratch_resources_for_patient(patient_id), path) do |coding|
-              coding.code.present? && coding.system.present?
+          when FHIR::Reference
+            element.reference
+          when FHIR::CodeableConcept
+            if include_system
+              coding =
+                find_a_value_at(element, 'coding') { |coding| coding.code.present? && coding.system.present? }
+              coding.present? ? "#{coding.system}|#{coding.code}" : nil
+            else
+              find_a_value_at(element, 'coding.code')
+            end
+          when FHIR::Identifier
+            if include_system
+              identifier = find_a_value_at(scratch_resources_for_patient(patient_id), path) do |identifier|
+                identifier.value.present? && identifier.system.present?
+              end
+              identifier.present? ? "#{identifier.system}|#{identifier.value}" : nil
+            else
+              element.value
+            end
+          when FHIR::Coding
+            if include_system
+              coding = find_a_value_at(scratch_resources_for_patient(patient_id), path) do |coding|
+                coding.code.present? && coding.system.present?
+              end
+              coding.present? ? "#{coding.system}|#{coding.code}" : nil
+            else
+              element.code
             end
-            coding.present? ? "#{coding.system}|#{coding.code}" : nil
+          when FHIR::HumanName
+            element.family || element.given&.first || element.text
+          when FHIR::Address
+            element.text || element.city || element.state || element.postalCode || element.country
           else
-            element.code
+            element
           end
-        when FHIR::HumanName
-          element.family || element.given&.first || element.text
-        when FHIR::Address
-          element.text || element.city || element.state || element.postalCode || element.country
-        else
-          element
-        end
+
+          break if search_value.present?
+      end
+
       escaped_value = search_value&.gsub(',', '\\,')
       escaped_value
     end
@@ -593,88 +604,96 @@ module USCoreTestKit
 
     def check_resource_against_params(resource, params)
       params.each do |name, search_value|
-        path = search_param_path(name)
-        type = metadata.search_definitions[name.to_sym][:type]
-        values_found =
-          resolve_path(resource, path)
-            .map do |value|
-              if value.is_a? FHIR::Reference
-                value.reference
-              else
-                value
+        paths = search_param_paths(name)
+
+        match_found = false
+        values_found = []
+
+        paths.each do |path|
+          type = metadata.search_definitions[name.to_sym][:type]
+          values_found =
+            resolve_path(resource, path)
+              .map do |value|
+                if value.is_a? FHIR::Reference
+                  value.reference
+                else
+                  value
+                end
               end
-            end
 
-        match_found =
-          case type
-          when 'Period', 'date', 'instant', 'dateTime'
-            values_found.any? { |date| validate_date_search(search_value, date) }
-          when 'HumanName'
-            # When a string search parameter refers to the types HumanName and Address,
-            # the search covers the elements of type string, and does not cover elements such as use and period
-            # https://www.hl7.org/fhir/search.html#string
-            search_value_downcase = search_value.downcase
-            values_found.any? do |name|
-              name&.text&.downcase&.start_with?(search_value_downcase) ||
-                name&.family&.downcase&.start_with?(search_value_downcase) ||
-                name&.given&.any? { |given| given.downcase.start_with?(search_value_downcase) } ||
-                name&.prefix&.any? { |prefix| prefix.downcase.start_with?(search_value_downcase) } ||
-                name&.suffix&.any? { |suffix| suffix.downcase.start_with?(search_value_downcase) }
-            end
-          when 'Address'
-            search_value_downcase = search_value.downcase
-            values_found.any? do |address|
-              address&.text&.downcase&.start_with?(search_value_downcase) ||
-              address&.city&.downcase&.start_with?(search_value_downcase) ||
-              address&.state&.downcase&.start_with?(search_value_downcase) ||
-              address&.postalCode&.downcase&.start_with?(search_value_downcase) ||
-              address&.country&.downcase&.start_with?(search_value_downcase)
-            end
-          when 'CodeableConcept'
-            # FHIR token search (https://www.hl7.org/fhir/search.html#token): "When in doubt, servers SHOULD 
-            # treat tokens in a case-insensitive manner, on the grounds that including undesired data has 
-            # less safety implications than excluding desired behavior". 
-            codings = values_found.flat_map(&:coding)
-            if search_value.include? '|'
-              system = search_value.split('|').first
-              code = search_value.split('|').last
-              codings&.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
-            else
-              codings&.any? { |coding| coding.code&.casecmp?(search_value) }
-            end
-          when 'Coding'
-            if search_value.include? '|'
-              system = search_value.split('|').first
-              code = search_value.split('|').last
-              values_found.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
-            else
-              values_found.any? { |coding| coding.code&.casecmp?(search_value) }
-            end
-          when 'Identifier'
-            if search_value.include? '|'
-              values_found.any? { |identifier| "#{identifier.system}|#{identifier.value}" == search_value }
-            else
-              values_found.any? { |identifier| identifier.value == search_value }
-            end
-          when 'string'
-            searched_values = search_value.downcase.split(/(?<!\\\\),/).map{ |string| string.gsub('\\,', ',') }
-            values_found.any? do |value_found|
-              searched_values.any? { |searched_value| value_found.downcase.starts_with? searched_value }
-            end
-          else
-            # searching by patient requires special case because we are searching by a resource identifier
-            # references can also be URL's, so we made need to resolve those url's
-            if ['subject', 'patient'].include? name.to_s
-              id = search_value.split('Patient/').last
-              possible_values = [id, 'Patient/' + id, "#{url}/Patient/\#{id}"]
-              values_found.any? do |reference|
-                possible_values.include? reference
+          match_found =
+            case type
+            when 'Period', 'date', 'instant', 'dateTime'
+              values_found.any? { |date| validate_date_search(search_value, date) }
+            when 'HumanName'
+              # When a string search parameter refers to the types HumanName and Address,
+              # the search covers the elements of type string, and does not cover elements such as use and period
+              # https://www.hl7.org/fhir/search.html#string
+              search_value_downcase = search_value.downcase
+              values_found.any? do |name|
+                name&.text&.downcase&.start_with?(search_value_downcase) ||
+                  name&.family&.downcase&.start_with?(search_value_downcase) ||
+                  name&.given&.any? { |given| given.downcase.start_with?(search_value_downcase) } ||
+                  name&.prefix&.any? { |prefix| prefix.downcase.start_with?(search_value_downcase) } ||
+                  name&.suffix&.any? { |suffix| suffix.downcase.start_with?(search_value_downcase) }
+              end
+            when 'Address'
+              search_value_downcase = search_value.downcase
+              values_found.any? do |address|
+                address&.text&.downcase&.start_with?(search_value_downcase) ||
+                address&.city&.downcase&.start_with?(search_value_downcase) ||
+                address&.state&.downcase&.start_with?(search_value_downcase) ||
+                address&.postalCode&.downcase&.start_with?(search_value_downcase) ||
+                address&.country&.downcase&.start_with?(search_value_downcase)
+              end
+            when 'CodeableConcept'
+              # FHIR token search (https://www.hl7.org/fhir/search.html#token): "When in doubt, servers SHOULD 
+              # treat tokens in a case-insensitive manner, on the grounds that including undesired data has 
+              # less safety implications than excluding desired behavior". 
+              codings = values_found.flat_map(&:coding)
+              if search_value.include? '|'
+                system = search_value.split('|').first
+                code = search_value.split('|').last
+                codings&.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
+              else
+                codings&.any? { |coding| coding.code&.casecmp?(search_value) }
+              end
+            when 'Coding'
+              if search_value.include? '|'
+                system = search_value.split('|').first
+                code = search_value.split('|').last
+                values_found.any? { |coding| coding.system == system && coding.code&.casecmp?(code) }
+              else
+                values_found.any? { |coding| coding.code&.casecmp?(search_value) }
+              end
+            when 'Identifier'
+              if search_value.include? '|'
+                values_found.any? { |identifier| "#{identifier.system}|#{identifier.value}" == search_value }
+              else
+                values_found.any? { |identifier| identifier.value == search_value }
+              end
+            when 'string'
+              searched_values = search_value.downcase.split(/(?<!\\\\),/).map{ |string| string.gsub('\\,', ',') }
+              values_found.any? do |value_found|
+                searched_values.any? { |searched_value| value_found.downcase.starts_with? searched_value }
               end
             else
-              search_values = search_value.split(/(?<!\\\\),/).map { |string| string.gsub('\\,', ',') }
-              values_found.any? { |value_found| search_values.include? value_found }
+              # searching by patient requires special case because we are searching by a resource identifier
+              # references can also be URLs, so we may need to resolve those URLs
+              if ['subject', 'patient'].include? name.to_s
+                id = search_value.split('Patient/').last
+                possible_values = [id, "Patient/#{id}", "#{url}/Patient/#{id}"]
+                values_found.any? do |reference|
+                  possible_values.include? reference
+                end
+              else
+                search_values = search_value.split(/(?<!\\\\),/).map { |string| string.gsub('\\,', ',') }
+                values_found.any? { |value_found| search_values.include? value_found }
+              end
             end
-          end
+          
+          break if match_found
+        end
 
         assert match_found,
                "#{resource_type}/#{resource.id} did not match the search parameters:\n" \

data/lib/us_core_test_kit/version.rb

@@ -1,3 +1,3 @@
 module USCoreTestKit
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/us_core_test_kit.rb

@@ -1,2 +1,3 @@
 require_relative 'us_core_test_kit/ext/fhir_models'
-require_relative 'us_core_test_kit/generated/us_core_test_suite'
+require_relative 'us_core_test_kit/generated/v3.1.1/us_core_test_suite'
+require_relative 'us_core_test_kit/generated/v4.0.0/us_core_test_suite'