pacio_inferno_core 0.1.0

data/lib/pacio_inferno_core/generator/value_extractor.rb

@@ -0,0 +1,152 @@
+module PacioInfernoCore
+  class Generator
+    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/pacio_inferno_core/generator.rb

@@ -0,0 +1,130 @@
+require 'fhir_models'
+require 'inferno/ext/fhir_models'
+
+require_relative 'generator/ig_loader'
+require_relative 'generator/ig_metadata_extractor'
+require_relative 'generator/group_generator'
+require_relative 'generator/must_support_test_generator'
+require_relative 'generator/read_test_generator'
+require_relative 'generator/reference_resolution_test_generator'
+require_relative 'generator/search_test_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/validation_test_generator'
+
+module PacioInfernoCore
+  class Generator
+    # def self.generate
+    #   ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'us_core_test_kit', 'igs', '*.tgz'))
+
+    #   ig_packages.each do |ig_package|
+    #     new(ig_package).generate
+    #   end
+    # end
+
+    attr_accessor :ig_resources, :ig_metadata, :ig_file_name
+
+    def initialize(ig_file_name)
+      self.ig_file_name = ig_file_name
+    end
+
+    def generate
+      puts "Generating tests for IG #{File.basename(ig_file_name)}"
+      load_ig_package
+      extract_metadata
+      generate_search_tests
+      generate_read_tests
+      # TODO: generate_vread_tests
+      # TODO: generate_history_tests
+      generate_provenance_revinclude_search_tests
+      generate_validation_tests
+      generate_must_support_tests
+      generate_reference_resolution_tests
+      generate_practitioner_address_tests
+      generate_interpreter_required_extension_test_generator
+
+      generate_granular_scope_tests
+
+      generate_groups
+
+      generate_granular_scope_resource_type_groups
+
+      generate_granular_scope_groups
+
+      generate_suites
+
+      write_metadata
+    end
+
+    def extract_metadata
+      self.ig_metadata = IGMetadataExtractor.new(ig_resources).extract
+
+      FileUtils.mkdir_p(base_output_dir)
+    end
+
+    def write_metadata
+      File.write(File.join(base_output_dir, 'metadata.yml'), YAML.dump(ig_metadata.to_hash))
+    end
+
+    def base_output_dir
+      File.join(__dir__, 'generated', ig_metadata.ig_version)
+    end
+
+    def load_ig_package
+      FHIR.logger = Logger.new('/dev/null')
+      self.ig_resources = IGLoader.new(ig_file_name).load
+    end
+
+    def generate_reference_resolution_tests
+      ReferenceResolutionTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_must_support_tests
+      MustSupportTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_validation_tests
+      ValidationTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_read_tests
+      ReadTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_search_tests
+      SearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_provenance_revinclude_search_tests
+      ProvenanceRevincludeSearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_granular_scope_tests
+      GranularScopeTestGenerator.generate(ig_metadata, base_output_dir)
+      GranularScopeReadTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_groups
+      GroupGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_granular_scope_resource_type_groups
+      GranularScopeResourceTypeGroupGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_granular_scope_groups
+      GranularScopeGroupGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_practitioner_address_tests
+      PractitionerAddressTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_interpreter_required_extension_test_generator
+      InterpreterRequiredExtensionTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_suites
+      SuiteGenerator.generate(ig_metadata, base_output_dir)
+    end
+  end
+end

data/lib/pacio_inferno_core/must_support_test.rb

@@ -0,0 +1,20 @@
+require_relative 'fhir_resource_navigation'
+
+module PacioInfernoCore
+  module 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/pacio_inferno_core/primitive_type.rb

@@ -0,0 +1,5 @@
+module PacioInfernoCore
+  # 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/pacio_inferno_core/read_test.rb

@@ -0,0 +1,103 @@
+module PacioInfernoCore
+  module 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)
+      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
+        .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

data/lib/pacio_inferno_core/reference_resolution_test.rb

@@ -0,0 +1,181 @@
+require_relative 'fhir_resource_navigation'
+
+module PacioInfernoCore
+  module ReferenceResolutionTest
+    include Inferno::DSL::FHIRResourceNavigation
+    extend Forwardable
+
+    def_delegators 'self.class', :metadata
+
+    def perform_reference_resolution_test(resources)
+      skip_if resources.blank?, no_resources_skip_message
+
+      pass if unresolved_references(resources).length.zero?
+
+      skip "Could not resolve and validate any Must Support references for #{unresolved_references_strings.join(', ')}"
+    end
+
+    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 do |path, profiles|
+        "#{path} element: Reference#{"(#{profiles.join('|')})" unless profiles.first.empty?}"
+      end
+    end
+
+    def record_resolved_reference(reference, target_profile)
+      saved_reference = resolved_references.find { |item| item[:reference] == reference.reference }
+
+      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 is_reference_resolved?(reference, target_profile)
+      resolved_references.any? do |item|
+        item[:reference] == reference.reference &&
+          (
+            target_profile.blank? || item[:profiles].include?(target_profile)
+          )
+      end
+    end
+
+    def resolved_references
+      scratch[:resolved_references] ||= Set.new
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+        'Please use patients with more information.'
+    end
+
+    def must_support_references
+      metadata.must_supports[:elements].select do |element_definition|
+        element_definition[:types]&.include?('Reference')
+      end
+    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]
+
+          found_one_reference = false
+
+          resolve_one_reference = resources.any? do |resource|
+            value_found = resolve_path(resource, path)
+            next if value_found.empty?
+
+            found_one_reference = true
+
+            value_found.any? do |reference|
+              validate_reference_resolution(resource, reference, target_profile)
+            end
+          end
+
+          found_one_reference && !resolve_one_reference
+        end
+
+      if metadata.must_supports[:choices].present?
+        @unresolved_references.delete_if do |reference|
+          choice_profiles = metadata.must_supports[:choices].find do |choice|
+            choice[:target_profiles]&.include?(reference[:target_profile])
+          end
+
+          choice_profiles.present? &&
+            choice_profiles[:target_profiles]&.any? do |profile|
+              @unresolved_references.none? do |element|
+                element[:target_profile] == profile
+              end
+            end
+        end
+      end
+
+      @unresolved_references
+    end
+
+    def validate_reference_resolution(resource, reference, target_profile)
+      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 = resolve_reference(reference)
+
+      return false if resolved_resource.nil?
+
+      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 resolve_reference(reference)
+      reference_type = reference.resource_type
+      reference_id = reference.reference_id
+
+      begin
+        if reference.relative?
+          begin
+            reference.resource_class
+          rescue NameError
+            return nil
+          end
+
+          fhir_read(reference_type, reference_id)&.resource
+        elsif 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
+      rescue StandardError => e
+        Inferno::Application['logger'].error("Unable to resolve reference #{reference.reference}")
+        Inferno::Application['logger'].error(e.full_message)
+        nil
+      end
+    end
+
+    def resource_is_valid_with_target_profile?(resource, target_profile)
+      return true if target_profile.blank?
+
+      resource_is_valid?(resource:, profile_url: target_profile, add_messages_to_runnable: false)
+    end
+  end
+end

data/lib/pacio_inferno_core/request_logger.rb

@@ -0,0 +1,46 @@
+module Inferno
+  module Utils
+    # @private
+    module Middleware
+      class RequestLogger
+        def log_response(response, start_time, end_time, exception = nil)
+          elapsed = end_time - start_time
+          status, _response_headers, body = response if response
+          status, = response if exception
+
+          logger.info("#{status} in #{elapsed.in_milliseconds} ms")
+          return unless body.present?
+
+          body = body.join if body.is_a?(Array)
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+
+        def log_request(env)
+          method = env['REQUEST_METHOD']
+          scheme = env['rack.url_scheme']
+          host = env['HTTP_HOST']
+          path = env['REQUEST_URI']
+          query = env['rack.request.query_string']
+          body = env['rack.input']
+          body = body.instance_of?(Puma::NullIO) ? nil : body.string
+          query_string = query.blank? ? '' : "?#{query}"
+
+          logger.info("#{method} #{scheme}://#{host}#{path}#{query_string}")
+
+          return unless body.present?
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+      end
+    end
+  end
+end