inferno_core 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 511a1a15fdcb49bcf9a58821b087d8a42394085f6c735971857a2e45710b7269
-  data.tar.gz: 2635bf69d9662b8afbaea341348d8dbc446707c6804be1f491c555376b8e31a6
+  metadata.gz: afdf870396c4f72a853bcbc56b7f134c827391a0b0b2e956b47e79aa36fccdf8
+  data.tar.gz: d77d91fc728001379862adb5d740039704d3dd81fe184b8e11d3b99a650e5218
 SHA512:
-  metadata.gz: 3a31b3fe1f72ff67cc2be3c8ff11d7dfd7f6c7c203e84c55b2072f205343c6c522686accc2b927088d31ade270fa127d8ad741fbced1827497f4a3d8102d9df3
-  data.tar.gz: 1bc84724a28ae55cecc8550b51143f3c2f4ff414891c8241012ca1f94e7ea20915a801d3c3616b4ab5a4667caf12f42a273f589ad2537ab13faec9aa36144c7e
+  metadata.gz: 03ff313b070ce6d09ae5ec35c0f677ed30c04010915189fdf9361ddb0e69b5df9ae0bdb7350a9e8db041a3352cc183d60173b0598fc729273ccfdf1386b03351
+  data.tar.gz: 37ea35ed4bad96e583f935763f22865244d01ae8daed58b43b0a82d9e2b74d5a39efcc6995bdc087c19fa620eddbc131f81a6365aa8ece6b12dcf8db319c9245

data/lib/inferno/apps/cli/evaluate.rb

@@ -1,4 +1,5 @@
 require_relative '../../../inferno/dsl/fhir_evaluation/evaluator'
+require_relative '../../../inferno/dsl/fhir_evaluation/config'
 require_relative '../../../inferno/entities'
 require_relative '../../utils/ig_downloader'
 
@@ -12,21 +13,22 @@ module Inferno
 
       def evaluate(ig_path, data_path, _log_level)
         validate_args(ig_path, data_path)
-        _ig = get_ig(ig_path)
+        ig = get_ig(ig_path)
 
-        # Rule execution, and result output below will be integrated soon.
+        check_ig_version(ig)
 
-        # if data_path
-        #   DatasetLoader.from_path(File.join(__dir__, data_path))
-        # else
-        #   ig.examples
-        # end
+        data =
+          if data_path
+            DatasetLoader.from_path(File.join(__dir__, data_path))
+          else
+            ig.examples
+          end
 
-        # config = Config.new
-        # evaluator = Inferno::DSL::FHIREvaluation::Evaluator.new(data, config)
+        evaluator = Inferno::DSL::FHIREvaluation::Evaluator.new(ig)
 
-        # results = evaluate()
-        # output_results(results, options[:output])
+        config = Inferno::DSL::FHIREvaluation::Config.new
+        results = evaluator.evaluate(data, config)
+        output_results(results, options[:output])
       end
 
       def validate_args(ig_path, data_path)
@@ -46,7 +48,7 @@ module Inferno
           cache_directory = File.join(user_package_cache, ig_path.sub('@', '#'))
           ig = Inferno::Entities::IG.from_file(cache_directory)
         else
-          Tempfile.create('package.tgz') do |temp_file|
+          Tempfile.create(['package', '.tgz']) do |temp_file|
             load_ig(ig_path, nil, { force: true }, temp_file.path)
             ig = Inferno::Entities::IG.from_file(temp_file.path)
           end
@@ -55,6 +57,14 @@ module Inferno
         ig
       end
 
+      def check_ig_version(ig)
+        versions = ig.ig_resource.fhirVersion
+
+        return unless versions.any? { |v| v > '4.0.1' }
+
+        puts '**WARNING** The selected IG targets a FHIR version higher than 4.0.1, which is not supported by Inferno.'
+      end
+
       def user_package_cache
         File.join(Dir.home, '.fhir', 'packages')
       end

data/lib/inferno/apps/cli/templates/Dockerfile.tt

@@ -6,7 +6,6 @@ RUN mkdir -p $INSTALL_PATH
 
 WORKDIR $INSTALL_PATH
 
-ADD lib/<%= library_name %>/metadata.rb $INSTALL_PATH/lib/<%= library_name %>/metadata.rb
 ADD lib/<%= library_name %>/version.rb $INSTALL_PATH/lib/<%= library_name %>/version.rb
 ADD *.gemspec $INSTALL_PATH
 ADD Gemfile* $INSTALL_PATH

data/lib/inferno/apps/cli/templates/README.md.tt

@@ -3,6 +3,16 @@
 <%= human_name %> [Inferno](https://github.com/inferno-community/inferno-core) Test Kit
 for FHIR testing.
 
+## Getting Started
+
+The quickest way to run this test kit locally is with [Docker](https://www.docker.com/).
+
+- Install Docker
+- Clone this repository, or download an [official release](/releases) if available.
+- Run `./setup.sh` within the test kit directory to download necessary dependencies
+- Run `./run.sh` within the test kit directory to start the application
+- Navigate to `http://localhost`
+
 ## Instructions for Developing Your Test Kit
 
 Refer to the Inferno documentation for information about [setting up

data/lib/inferno/apps/cli/templates/docs/Overview.md

@@ -0,0 +1,7 @@
+This file was generated from the Inferno template to demonstrate providing
+documentation across multiple files, and has not yet customized for this test
+kit.
+
+For examples of test kit documentation, refer to the [US Core Test
+Kit](/inferno-framework/us-core-test-kit/wiki) and the [ONC Certification
+(g)(10) Test Kit](/inferno-framework/onc-certification-g10-test-kit/wiki).

data/lib/inferno/apps/cli/templates/docs/README.md.tt

@@ -0,0 +1,10 @@
+<%= human_name %> documentation. This file has been generated from the Inferno
+test kit template and has not yet been customized for this test kit.
+
+*Note to developer: After customizing this documentation, initialize a GitHub
+wiki within this repository to enable automatic publishing to the wiki via the
+included Publish Docs Wiki action.*
+
+## Using this Test Kit (example)
+* [Getting Started](../?tab=readme-ov-file#getting-started): Installation instructions for this test kit.
+* [Test Kit Overview](Overview.md): An overview of the test kit and its tests.

data/lib/inferno/apps/cli/templates/docs/_Footer.md

@@ -0,0 +1,5 @@
+_Test kit documentation is stored within the [./docs](../tree/main/docs) folder of
+this repository and is automatically synchronized to this wiki with each update
+to the `main` branch using the [Publish Docs Wiki
+workflow](../actions/workflows/publish-docs-wiki.yml).  Do not change content
+within this wiki directly as changes will be overwritten._

data/lib/inferno/apps/cli/templates/docs/_Sidebar.md

@@ -0,0 +1,5 @@
+**[Documentation Home](Home)**
+
+**Using this Test Kit**
+  - [Getting Started](../?tab=readme-ov-file#getting-started)
+  - [Test Kit Overview](Overview.md)

data/lib/inferno/config/boot/presets.rb

@@ -22,8 +22,8 @@ Inferno::Application.register_provider(:presets) do
       end
 
     files_to_load.compact!
-    files_to_load.uniq!
     files_to_load.map! { |path| File.realpath(path) }
+    files_to_load.uniq!
 
     files_to_load.each do |path|
       presets_repo.insert_from_file(path)

data/lib/inferno/dsl/auth_info.rb

@@ -307,9 +307,95 @@ module Inferno
         self.expires_in = expires_in
         self.issue_time = DateTime.now
 
-        add_to_client(client)
+        add_to_client(client) if client
         self
       end
+
+      # Returns the default configuration for the "auth_type" component
+      # @return [Hash]
+      def self.default_auth_type_component
+        {
+          name: :auth_type,
+          options: {
+            list_options: [
+              { label: 'Public', value: 'public' },
+              { label: 'Confidential Symmetric', value: 'symmetric' },
+              { label: 'Confidential Asymmetric', value: 'asymmetric' },
+              { label: 'Backend Services', value: 'backend_services' }
+            ]
+          }
+        }
+      end
+
+      # Returns the default configuration for the "auth_type" component without
+      # the option for backend services auth
+      # @return [Hash]
+      def self.default_auth_type_component_without_backend_services
+        {
+          name: :auth_type,
+          options: {
+            list_options: [
+              { label: 'Public', value: 'public' },
+              { label: 'Confidential Symmetric', value: 'symmetric' },
+              { label: 'Confidential Asymmetric', value: 'asymmetric' }
+            ]
+          }
+        }
+      end
+
+      # Returns true when using public auth
+      # @return [Boolean]
+      def public_auth?
+        auth_type&.casecmp? 'public'
+      end
+
+      # Returns true when using confidential symmetric auth
+      # @return [Boolean]
+      def symmetric_auth?
+        auth_type&.casecmp? 'symmetric'
+      end
+
+      # Returns true when using confidential asymmetric auth
+      # @return [Boolean]
+      def asymmetric_auth?
+        auth_type&.casecmp? 'asymmetric'
+      end
+
+      # Returns true when using backend services auth
+      # @return [Boolean]
+      def backend_services_auth?
+        auth_type&.casecmp? 'backend_services'
+      end
+
+      # Returns true when using GET as the authorization request method
+      # @return [Boolean]
+      def get_auth_request?
+        auth_request_method&.casecmp? 'get'
+      end
+
+      # Returns true when using POST as the authorization request method
+      # @return [Boolean]
+      def post_auth_request?
+        auth_request_method&.casecmp? 'post'
+      end
+
+      # Returns true when pkce is enabled
+      # @return [Boolean]
+      def pkce_enabled?
+        pkce_support&.casecmp? 'enabled'
+      end
+
+      # Returns true when using the S256 pkce code challenge method
+      # @return [Boolean]
+      def s256_code_challenge_method?
+        pkce_code_challenge_method&.casecmp? 'S256'
+      end
+
+      # Returns true when using the palin pkce code challenge method
+      # @return [Boolean]
+      def plain_code_challenge_method?
+        pkce_code_challenge_method&.casecmp? 'plain'
+      end
     end
   end
 end

data/lib/inferno/dsl/configurable.rb

@@ -138,6 +138,19 @@ module Inferno
           configuration[:inputs] ||= {}
         end
 
+        # @private
+        # Recursively duplicate arrays/hashes to prevent them from being shared
+        # across different runnables
+        def deep_dup(value)
+          if value.is_a? Array
+            value.map { |element| deep_dup(element) }
+          elsif value.is_a? Hash
+            value.transform_values { |element| deep_dup(element) }
+          else
+            value.dup
+          end
+        end
+
         # @private
         def add_input(identifier, new_config = {})
           existing_config = input(identifier)
@@ -148,7 +161,7 @@ module Inferno
 
           inputs[identifier] =
             Entities::Input
-              .new(**existing_config.to_hash)
+              .new(**deep_dup(existing_config.to_hash))
               .merge(Entities::Input.new(**new_config))
         end
 

data/lib/inferno/dsl/fhir_client.rb

@@ -327,6 +327,58 @@ module Inferno
         end
       end
 
+      # Fetch all resources from a paginated FHIR bundle
+      #
+      # @param resource_type [String] The expected resource type to fetch.
+      # @param bundle [FHIR::Bundle] The initial FHIR bundle to process. Defaults to `self.resource`.
+      # @param reply_handler [Proc, nil] A handler for processing replies. Optional.
+      # @param client [Symbol] Defaults to `:default`.
+      # @param max_pages [Integer] Maximum number of pages to fetch. Defaults to 20.
+      # @param additional_resource_types [Array<String>] Additional resource types acceptable in the results.
+      # @param tags [Array<String>] for request tagging. Optional.
+      #
+      # @return [Array<FHIR::Resource>] An array of fetched FHIR resources.
+      def fetch_all_bundled_resources( # rubocop:disable Metrics/CyclomaticComplexity
+        resource_type:,
+        bundle: resource,
+        reply_handler: nil,
+        client: :default,
+        max_pages: 20,
+        additional_resource_types: [],
+        tags: []
+      )
+        page_count = 1
+        resources = []
+
+        while bundle && page_count <= max_pages
+          resources += bundle.entry&.map { |entry| entry&.resource } || []
+          reply_handler&.call(response)
+
+          break if next_bundle_link(bundle).blank?
+
+          bundle = fetch_next_bundle(bundle, client, tags)
+
+          page_count += 1
+        end
+
+        valid_resource_types = [resource_type, 'OperationOutcome'].concat(additional_resource_types)
+
+        invalid_resource_types =
+          resources.reject { |entry| valid_resource_types.include? entry.resourceType }
+            .map(&:resourceType)
+            .uniq
+        if invalid_resource_types.any?
+          info "Received resource type(s) #{invalid_resource_types.join(', ')} in search bundle, " \
+               "but only expected resource types #{valid_resource_types.join(', ')}. " \
+               'This is unusual but allowed if the server believes additional resource types are relevant.'
+        end
+
+        resources
+      rescue JSON::ParserError
+        Inferno::Application[:logger].error "Could not resolve next bundle: #{next_bundle_link(bundle)}"
+        resources
+      end
+
       # @todo Make this a FHIR class method? Something like
       #   FHIR.class_for(resource_type)
       # @private
@@ -371,6 +423,20 @@ module Inferno
         Inferno::Application[:logger].error "Unable to refresh token: #{e.message}"
       end
 
+      # @private
+      def fetch_next_bundle(bundle, client, tags)
+        reply = fhir_client(client).raw_read_url(next_bundle_link(bundle))
+        store_request('outgoing', tags:) { reply }
+        return unless request.status == 200
+
+        fhir_client(client).parse_reply(FHIR::Bundle, fhir_client(client).default_format, reply)
+      end
+
+      # @private
+      def next_bundle_link(bundle)
+        bundle&.link&.find { |link| link.relation == 'next' }&.url
+      end
+
       module ClassMethods
         # @private
         def fhir_client_definitions

data/lib/inferno/dsl/fhir_evaluation/evaluation_context.rb

@@ -6,14 +6,16 @@ module Inferno
       # - The data being evaluated
       # - A summary/characterization of the data
       # - Evaluation results
+      # - A Validator instance, configured to point to the given IG
       class EvaluationContext
-        attr_reader :ig, :data, :results, :config
+        attr_reader :ig, :data, :results, :config, :validator
 
-        def initialize(ig, data, config) # rubocop:disable Naming/MethodParameterName
+        def initialize(ig, data, config, validator)
           @ig = ig
           @data = data
           @results = []
           @config = config
+          @validator = validator
         end
 
         def add_result(result)

data/lib/inferno/dsl/fhir_evaluation/evaluator.rb

@@ -6,18 +6,23 @@ require_relative 'evaluation_context'
 require_relative 'evaluation_result'
 require_relative 'dataset_loader'
 
+Dir.glob(File.join(__dir__, 'rules', '*.rb')).each do |file|
+  require_relative file
+end
+
 module Inferno
   module DSL
     module FHIREvaluation
       class Evaluator
-        attr_accessor :ig
+        attr_accessor :ig, :validator
 
-        def initialize(ig) # rubocop:disable Naming/MethodParameterName
+        def initialize(ig, validator = nil)
           @ig = ig
+          @validator = validator
         end
 
         def evaluate(data, config = Config.new)
-          context = EvaluationContext.new(@ig, data, config)
+          context = EvaluationContext.new(@ig, data, config, validator)
 
           active_rules = []
           config.data['Rule'].each do |rulename, rule_details|

data/lib/inferno/dsl/fhir_evaluation/profile_conformance_helper.rb

@@ -0,0 +1,66 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      # This module is used to decide whether a resource instantiates a given profile.
+      # Aligning resources to profiles is necessary when evaluating the comprehensiveness
+      # of the resources with respect to those profiles, unfortunately it's impossible to
+      # programmatically determine intent. (i.e, is this resource supposed to instantiate this profile?)
+      # This module offers some approaches to make that determination.
+      module ProfileConformanceHelper
+        DEFAULT_OPTIONS = {
+          considerMetaProfile: true,
+          considerValidationResults: false,
+          considerOnlyResourceType: false
+        }.freeze
+
+        # Check whether the given resource conforms to the given profile, using the given options
+        # to select which approaches are considered.
+        # Current options:
+        # - If the resource is the right resourceType
+        # - If the resource claims conformance in resource.meta.profile
+        # - If the resource validates against the profile using the FHIR validator (NOT YET IMPLEMENTED)
+        # - If the resource meets other criteria defined in the block.
+        #   As an example, the block may look for the presence of certain codes, such as LOINC "8867-4"
+        #   in an Observation category code suggests that the resource intended to conform to a "Heart Rate" profile
+        # @param resource [FHIR::Resource]
+        # @param profile [FHIR::StructureDefinition]
+        # @param options [Hash] Hash of boolean-valued options. See DEFAULT_OPTIONS for defaults and keys
+        # @param validator [Inferno::DSL::FHIRResourceValidation::Validator]
+        # @yieldparam resource [FHIR::Resource] The original resource
+        # @yieldreturn [Boolean]
+        # @return [Boolean]
+        def conforms_to_profile?(resource, profile, options = DEFAULT_OPTIONS, validator = nil) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if resource.resourceType != profile.type
+
+          return true if options[:considerOnlyResourceType]
+
+          return true if options[:considerMetaProfile] && declares_meta_profile?(resource, profile)
+
+          return true if options[:considerValidationResults] && validates_profile?(resource, profile, validator)
+
+          return true if block_given? && yield(resource)
+
+          false
+        end
+
+        # Check if the given resource claims conformance to the profile, versioned or unversioned,
+        # based on resource.meta.profile.
+        # @param resource [FHIR::Resource]
+        # @param profile [FHIR::StructureDefinition]
+        def declares_meta_profile?(resource, profile)
+          declared_profiles = resource&.meta&.profile || []
+          profile_url = profile.url
+          versioned_url = "#{profile_url}|#{profile.version}"
+
+          declared_profiles.include?(profile_url) || declared_profiles.include?(versioned_url)
+        end
+
+        # @private until implemented
+        def validates_profile?(_resource, _profile, _validator)
+          raise 'Profile validation is not yet implemented. ' \
+                'Set considerValidationResults=false.'
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/reference_extractor.rb

@@ -0,0 +1,61 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      class ReferenceExtractor
+        attr_accessor :resource_type_ids, :references
+
+        def extract_resource_type_ids(resources)
+          @resource_type_ids = Hash.new { |type, id| type[id] = [] }
+
+          resources.each do |resource|
+            resource.each_element do |value, metadata, path|
+              next unless metadata['type'] == 'id'
+              next if path.include?('contained')
+
+              type = metadata['path'].partition('.').first.downcase
+              resource_type_ids[type] << value
+            end
+          end
+
+          resource_type_ids
+        end
+
+        def extract_references(resources)
+          @references = Hash.new { |reference, id| reference[id] = [] }
+
+          resources.each do |resource|
+            extract_references_from_resource(resource)
+          end
+
+          references
+        end
+
+        def extract_references_from_resource(resource)
+          resource.each_element do |value, metadata, path|
+            if metadata['type'] == 'Reference' && !value.reference.nil?
+              if value.reference.start_with?('#')
+                next
+              elsif value.reference.include? '/'
+                add_parsed_reference(resource, value, path)
+              elsif value.reference.start_with? 'urn:uuid:'
+                references[resource.id] << { path: path, type: '', id: value.reference[9..] }
+              else
+                references[resource.id] << { path: path, type: '', id: value.reference }
+              end
+            end
+          end
+        end
+
+        def add_parsed_reference(resource, value, path)
+          type = value.reference.split('/')[-2].downcase
+          id = value.reference.split('/')[-1]
+          references[resource.id] << if resource_type_ids.key?(type)
+                                       { path: path, type: type, id: id }
+                                     else
+                                       { path: path, type: '', id: value.reference }
+                                     end
+        end
+      end
+    end
+  end
+end