us_quality_core_test_kit 0.1.0 → 0.1.2

data/lib/us_quality_core_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -1,10 +1,114 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/generator/terminology_binding_metadata_extractor'
-
 module USQualityCoreTestKit
   class Generator
-    class TerminologyBindingMetadataExtractor < USCoreTestKit::Generator::TerminologyBindingMetadataExtractor
+    class TerminologyBindingMetadataExtractor
+      attr_accessor :profile_elements, :ig_resources, :resource
+
+      def initialize(profile_elements, ig_resources, resource)
+        self.profile_elements = profile_elements
+        self.ig_resources = ig_resources
+        self.resource = resource
+      end
+
+      def terminology_bindings
+        (element_terminology_bindings + extension_terminology_bindings).compact
+      end
+
+      def element_has_fixed_value?(element)
+        case element.type.first.code
+        when 'Quantity'
+          code = profile_elements.find { |e| e.path == "#{element.path}.code" }
+          system = profile_elements.find { |e| e.path == "#{element.path}.system" }
+          code&.fixedCode || system&.fixedUri
+        when 'code'
+          element.fixedCode.present?
+        end
+      end
+
+      def element_has_optional_binding_slice?(element)
+        element.sliceName.present? && element.min.zero?
+      end
+
+      def profile_elements_with_bindings
+        profile_elements
+          .select { |element| element.binding.present? && element.binding.strength == 'required' }
+          .reject { |element| element_has_fixed_value?(element) || element_has_optional_binding_slice?(element) }
+      end
+
+      def element_terminology_bindings
+        profile_elements_with_bindings.map do |element|
+          binding = {
+            type: element.type.first.code,
+            strength: element.binding.strength,
+            system: element.binding.valueSet&.split('|')&.first,
+            path: element.path.gsub('[x]', '').gsub("#{resource}.", '')
+          }
+
+          binding[:required_binding_slice] = true if element.sliceName.present? && element.min.positive?
+
+          binding
+        end
+      end
+
+      def extension_profile_elements
+        profile_elements
+          .select { |element| element.type&.first&.code == 'Extension' }
+          .select { |element| extension_profile_url(element).present? }
+      end
+
+      def extension_profile_url(extension)
+        extension.type.first.profile&.first
+      end
+
+      def extension_terminology_bindings
+        extension_profile_elements
+          .flat_map do |extension_profile_element|
+            url = extension_profile_url(extension_profile_element)
+            extension = ig_resources.profile_by_url(url)
+
+            # TODO: Temporaray fix for extension defined out of US Core. FI-1623
+            next if extension.nil?
+
+            elements = extension.snapshot.element
+            elements_with_bindings = elements.select do |element|
+              element.binding.present? && !element.id.include?('Extension.extension')
+            end
+
+            elements_with_bindings.map do |element|
+              {
+                type: element.type.first.code,
+                strength: element.binding.strength,
+                system: element.binding.valueSet&.split('|')&.first,
+                path: element.path.gsub('[x]', '').gsub('Extension.', ''),
+                extensions: [url]
+              }
+            end + nested_extension_terminology_bindings(elements, url)
+          end
+      end
+
+      def nested_extension_terminology_bindings(elements, extension_url)
+        nested_extensions = elements.select { |element| element.path == 'Extension.extension' }
+        nested_extensions.flat_map do |nested_extension|
+          nested_extension_element = elements.find { |element| element.id == "#{nested_extension.id}.url" }
+          next unless nested_extension_element.present?
+
+          nested_extension_url = nested_extension_element.fixedUri
+          nested_elements_with_bindings = elements.select do |element|
+            element.id.include?(nested_extension.id) && element.binding.present?
+          end
+
+          nested_elements_with_bindings.map do |element|
+            {
+              type: element.type.first.code,
+              strength: element.binding.strength,
+              system: element.binding.valueSet&.split('|')&.first,
+              path: element.path.gsub('[x]', '').gsub('Extension.extension.', ''),
+              extensions: [extension_url, nested_extension_url]
+            }
+          end
+        end
+      end
     end
   end
 end

data/lib/us_quality_core_test_kit/generator/validation_test_generator.rb

@@ -1,13 +1,71 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/generator/validation_test_generator'
-
 require_relative 'naming'
 require_relative 'special_cases'
 
 module USQualityCoreTestKit
   class Generator
-    class ValidationTestGenerator < USCoreTestKit::Generator::ValidationTestGenerator
+    class ValidationTestGenerator
+      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir
+
+      def initialize(group_metadata, medication_request_metadata = nil, base_output_dir:)
+        self.group_metadata = group_metadata
+        self.medication_request_metadata = medication_request_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def output
+        @output ||= ERB.new(template, trim_mode: '-').result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(base_output_dir, directory_name)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def profile_url
+        group_metadata.profile_url
+      end
+
+      def profile_name
+        group_metadata.profile_name
+      end
+
+      def profile_version
+        group_metadata.profile_version
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        read_interaction[:expectation]
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.write(output_file_name, output)
+
+        test_metadata = {
+          id: test_id,
+          file_name: base_output_file_name
+        }
+
+        if resource_type == 'Medication'
+          medication_request_metadata.add_test(**test_metadata)
+        else
+          group_metadata.add_test(**test_metadata)
+        end
+      end
+
       class << self
         def generate(ig_metadata, base_output_dir)
           ig_metadata.groups
@@ -49,7 +107,7 @@ module USQualityCoreTestKit
       end
 
       def description
-        <<~DESCRIPTION
+        base_description = <<~DESCRIPTION
           #{description_intro}
           It verifies the presence of mandatory elements and that elements with
           required bindings contain appropriate values. CodeableConcept element
@@ -57,6 +115,27 @@ module USQualityCoreTestKit
           to the bound ValueSet. Quantity, Coding, and code element bindings will
           fail if their code/system are not found in the valueset.
         DESCRIPTION
+
+        filter_note = validation_message_filter_note
+        return base_description unless filter_note
+
+        "#{base_description}\n#{filter_note}"
+      end
+
+      def validation_message_filter_note
+        case resource_type
+        when 'Patient'
+          <<~NOTE
+            Note: This test ignores validator messages for `Patient.extension`. This is a workaround for
+            a known validator package interaction where CQL can load US Core 7 definitions into the
+            validator session even though US Quality Core 0.5.0 is based on US Core 6.1.0.
+          NOTE
+        when 'DeviceRequest'
+          <<~NOTE
+            Note: This test ignores a known validator slicing resolution message for
+            `DeviceRequest.modifierExtension`.
+          NOTE
+        end
       end
 
       def description_intro

data/lib/us_quality_core_test_kit/generator/value_extractor.rb

@@ -1,10 +1,154 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/generator/value_extractor'
-
 module USQualityCoreTestKit
   class Generator
-    class ValueExactor < USCoreTestKit::Generator::ValueExactor
+    class ValueExactor
+      attr_accessor :ig_resources, :resource, :profile_elements
+
+      def initialize(ig_resources, resource, profile_elements)
+        self.ig_resources = ig_resources
+        self.resource = resource
+        self.profile_elements = profile_elements
+      end
+
+      def values_from_fixed_codes(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == "#{profile_element.path}.coding.code" && element.fixedCode.present?
+        end
+
+        elements.map(&:fixedCode)
+      end
+
+      def values_from_pattern_coding(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == "#{profile_element.path}.coding" && element.patternCoding.present?
+        end
+
+        elements.map { |element| element.patternCoding.code }
+      end
+
+      def values_from_pattern_codeable_concept(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        elements = profile_elements.select do |element|
+          element.path == profile_element.path && element.patternCodeableConcept.present? && element.min.positive?
+        end
+
+        elements.map { |element| element.patternCodeableConcept.coding.first.code }
+      end
+
+      def value_set_binding(the_element)
+        the_element&.binding
+      end
+
+      def value_set(the_element)
+        binding = value_set_binding(the_element)
+        target_valueset = binding&.valueSet
+
+        additional_binding_ext = binding&.extension&.find do |ext|
+          ext.url == 'http://hl7.org/fhir/tools/StructureDefinition/additional-binding' &&
+            ext.extension.any? { |sub_ext| sub_ext.url == 'purpose' && sub_ext.valueCode == 'minimum' }
+        end
+
+        min_valueset_ext = binding&.extension&.find do |ext|
+          ext.url == 'http://hl7.org/fhir/StructureDefinition/elementdefinition-minValueSet'
+        end
+
+        if additional_binding_ext.present?
+          min_valueset = additional_binding_ext.extension.find { |ext| ext.url == 'valueSet' }
+
+          target_valueset = min_valueset.valueCanonical if min_valueset.present?
+        elsif min_valueset_ext.present?
+          target_valueset = min_valueset_ext.valueCanonical
+        end
+
+        ig_resources.value_set_by_url(target_valueset)
+      end
+
+      def bound_systems(the_element)
+        bound_systems_from_valueset(value_set(the_element))
+      end
+
+      def bound_systems_from_valueset(value_set)
+        value_set&.compose&.include&.map do |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 include_element.valueSet.present?
+            include_element.valueSet.map do |vs|
+              a_value_set = ig_resources.value_set_by_url(vs)
+              bound_systems_from_valueset(a_value_set)
+            end
+          end
+        end&.flatten&.compact
+      end
+
+      def codes_from_value_set_binding(the_element)
+        codes_from_system_code_pair(codings_from_value_set_binding(the_element))
+      end
+
+      def codes_from_system_code_pair(codings)
+        codings.present? ? codings.map { |coding| coding[:code] }.compact.uniq : []
+      end
+
+      def codings_from_value_set_binding(the_element)
+        return [] if the_element.nil?
+
+        bound_systems = bound_systems(the_element)
+
+        return codings_from_bound_systems(bound_systems) if bound_systems.present?
+
+        expansion_contains = value_set_expansion_contains(the_element)
+
+        return [] if expansion_contains.blank?
+
+        expansion_contains.map { |contains| { system: contains.system, code: contains.code } }.compact.uniq
+      end
+
+      def codings_from_bound_systems(bound_systems)
+        return [] unless bound_systems.present?
+
+        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 } }
+          when FHIR::CodeSystem
+            bound_system.concept.map { |concept| { system: bound_system.url, code: concept.code } }
+          else
+            []
+          end
+        end.uniq
+      end
+
+      def value_set_expansion_contains(element)
+        value_set(element)&.expansion&.contains
+      end
+
+      def fhir_metadata(current_path)
+        FHIR.const_get(resource)::METADATA[current_path]
+      end
+
+      def values_from_resource_metadata(paths)
+        values = []
+
+        paths.each do |current_path|
+          current_metadata = fhir_metadata(current_path)
+
+          next unless current_metadata&.dig('valid_codes').present?
+
+          values += current_metadata['valid_codes'].flat_map do |system, codes|
+            codes.map { |code| { system:, code: } }
+          end
+        end
+
+        values
+      end
     end
   end
 end

data/lib/us_quality_core_test_kit/must_support_test.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/must_support_test'
+require_relative 'fhir_resource_navigation'
 
 module USQualityCoreTestKit
   module MustSupportTest
-    include USCoreTestKit::MustSupportTest
-    extend USCoreTestKit::MustSupportTest
+    include Inferno::DSL::FHIRResourceNavigation
+    extend Forwardable
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all]
+    end
+
+    def perform_must_support_test(resources)
+      skip_if resources.blank?, "No #{resource_type} resources were found"
+
+      skip { assert_must_support_elements_present(resources, nil, metadata:) }
+    end
   end
 end

data/lib/us_quality_core_test_kit/primitive_type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  # This functionality has been moved to Inferno Core, but this reference is
+  # retained to avoid a breaking change.
+  PrimitiveType = Inferno::DSL::PrimitiveType
+end

data/lib/us_quality_core_test_kit/read_test.rb

@@ -1,10 +1,105 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/read_test'
-
 module USQualityCoreTestKit
   module ReadTest
-    include USCoreTestKit::ReadTest
-    extend USCoreTestKit::ReadTest
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def perform_read_test(resources, _reply_handler = nil, delayed_reference: false)
+      skip_if resources.blank?, no_resources_skip_message
+
+      resources_to_read = if delayed_reference
+                            readable_references(resources)
+                          else
+                            readable_resources(resources)
+                          end
+
+      assert resources_to_read.present?, "No #{resource_type} id found."
+
+      if config.options[:read_all_resources]
+        if delayed_reference
+          all_referencing_resources = referencing_resources(resources_to_read)
+          info %(
+            The #{resource_type} references used for this test were pulled from the following resources:
+            #{all_referencing_resources}
+          )
+
+          resources_to_read.map! { |resource| resource[:reference] }
+        end
+
+        resources_to_read.each do |resource|
+          read_and_validate(resource)
+        end
+      else
+        first_resource = resources_to_read.first
+        if delayed_reference.present?
+          info %(
+            The #{resource_type} reference used for this test was pulled from resource
+            #{first_resource[:referencing_resource]}
+          )
+          first_resource = first_resource[:reference]
+        end
+        read_and_validate(first_resource)
+      end
+    end
+
+    def referencing_resources(readable_resources)
+      readable_resources
+        .map { |resource| resource[:referencing_resource] }
+        .join(', ')
+    end
+
+    def readable_references(resources)
+      references = resources.filter_map do |resource|
+        next unless resource[:reference].present? && resource[:reference].is_a?(FHIR::Reference)
+
+        reference_id = resource[:reference].reference&.split('/')&.last
+        next unless reference_id&.present?
+
+        resource
+      end
+
+      references.uniq { |resource| resource[:reference].reference.split('/').last }
+    end
+
+    def readable_resources(resources)
+      resources
+        .select { |resource| resource.is_a?(resource_class) || resource.is_a?(FHIR::Reference) }
+        .select { |resource| (resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id).present? }
+        .compact
+        .uniq { |resource| resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id }
+    end
+
+    def read_and_validate(resource_to_read)
+      id = resource_id(resource_to_read)
+
+      fhir_read resource_type, id
+
+      assert_response_status(200)
+      assert_resource_type(resource_type)
+      assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
+
+      return unless resource_to_read.is_a? FHIR::Reference
+
+      all_scratch_resources << resource
+    end
+
+    def resource_id(resource)
+      resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+        'Please use patients with more information.'
+    end
+
+    def bad_resource_id_message(expected_id)
+      "Expected resource to have id: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
+    end
+
+    def resource_class
+      FHIR.const_get(resource_type)
+    end
   end
 end