inferno_core 0.6.7 → 0.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48f096486362742aa31ed9f7edec9df07786be3ac7e4f5dfdf121c65b61da1e5
-  data.tar.gz: d6edfd6063f0ba5b83708b86ee5ccc9e0302a32e9a1f96473bbabeabc2d18184
+  metadata.gz: 5740a0c7e8d54767851b4f7e9ee7c5c6ca9ac175211d63b4990f99bbbe9266ca
+  data.tar.gz: 4fd1b9c5cb4f37c441a668ae58c8b6cd49aeea18ad393b2d7bbb9699d86a0060
 SHA512:
-  metadata.gz: e065c783d7def8ca873e964f61b9ab4cfcf01a352c99e63157d11eb5ca909f617ee031d5421e26b244caa4f36831ae6574160ac59e2d99647aa2d6d99a152fa0
-  data.tar.gz: 68c8b17c1c635fc4e2986d1e56b06225aa858cf0c049447957c33982f16d0587a0f0407f24c4164ca8b9c08fdbbe6adae693f7a6b1abf0fd9ca258efc50c7db1
+  metadata.gz: f6adc91f5db1ba2a6535c847c0fe7b691cd85455fb0f34a44bd525428dee3ddcd4c414d7989ea4e13fdd50b9c39778a19d26e97473f1617b85691b4683776f49
+  data.tar.gz: 463d68cf3e187f992bd134bbc177072bfaa9ec625a2006ca1bb23c49591a4bc9521ca027232c68c5d1ebcf499dcca84f3f722ca2afd9bd1b6038bbb19daf4835

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

@@ -1,7 +1,6 @@
 require_relative '../../dsl/fhir_evaluation/evaluator'
 require_relative '../../dsl/fhir_evaluation/config'
 require_relative '../../entities'
-require_relative '../../repositories'
 require_relative '../../utils/ig_downloader'
 
 require 'tempfile'
@@ -10,6 +9,12 @@ module Inferno
   module CLI
     class Evaluate < Thor::Group
       def evaluate(ig_path, data_path, _log_level)
+        # NOTE: repositories is required here rather than at the top of the file because
+        # the tree of requires means that this file and its requires get required by every CLI app.
+        # Sequel::Model, used in some repositories, fetches the table schema at instantiation.
+        # This breaks the `migrate` task by fetching a table before the task runs/creates it.
+        require_relative '../../repositories'
+
         validate_args(ig_path, data_path)
         ig = Inferno::Repositories::IGs.new.find_or_load(ig_path)
 

data/lib/inferno/apps/cli/templates/lib/%library_name%/suite.rb.tt

@@ -13,13 +13,13 @@ module <%= module_name %>
 
     input :credentials,
           title: 'OAuth Credentials',
-          type: :oauth_credentials,
+          type: :auth_info,
           optional: true
 
     # All FHIR requests in this suite will use this FHIR client
     fhir_client do
       url :url
-      oauth_credentials :credentials
+      auth_info :credentials
     end
 
     # All FHIR validation requests will use this FHIR validator

data/lib/inferno/apps/web/controllers/requirements/show.rb

@@ -0,0 +1,18 @@
+require_relative '../../serializers/requirement'
+
+module Inferno
+  module Web
+    module Controllers
+      module Requirements
+        class Show < Controller
+          def handle(req, res)
+            requirement = repo.find(req.params[:id])
+            halt 404 if requirement.nil?
+
+            res.body = serialize(requirement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/web/controllers/test_suites/requirements/index.rb

@@ -0,0 +1,29 @@
+module Inferno
+  module Web
+    module Controllers
+      module TestSuites
+        module Requirements
+          class Index < Controller
+            include Import[test_suites_repo: 'inferno.repositories.test_suites']
+            include Import[test_sessions_repo: 'inferno.repositories.test_sessions']
+
+            def handle(req, res)
+              test_suite = test_suites_repo.find(req.params[:id])
+              halt 404, "Test Suite `#{req.params[:id]}` not found" if test_suite.nil?
+
+              test_session = nil
+              if req.params[:session_id]
+                test_session = test_sessions_repo.find(req.params[:session_id])
+                halt 404, "Test session `#{req.params[:session_id]}` not found" if test_session.nil?
+              end
+
+              requirements = repo.requirements_for_suite(test_suite.id, test_session&.id)
+
+              res.body = serialize(requirements)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/web/router.rb

@@ -47,6 +47,13 @@ module Inferno
           put '/:id/check_configuration',
               to: Inferno::Web::Controllers::TestSuites::CheckConfiguration,
               as: :check_configuration
+          get ':id/requirements',
+              to: Inferno::Web::Controllers::TestSuites::Requirements::Index,
+              as: :requirements
+        end
+
+        scope 'requirements' do
+          get '/:id', to: Inferno::Web::Controllers::Requirements::Show, as: :show
         end
 
         get '/requests/:id', to: Inferno::Web::Controllers::Requests::Show, as: :requests_show

data/lib/inferno/apps/web/serializers/requirement.rb

@@ -0,0 +1,18 @@
+require_relative 'serializer'
+
+module Inferno
+  module Web
+    module Serializers
+      class Requirement < Serializer
+        identifier :id
+
+        field :requirement
+        field :conformance
+        field :actor
+        field :sub_requirements
+        field :conditionality
+        field :url, if: :field_present?
+      end
+    end
+  end
+end

data/lib/inferno/apps/web/serializers/requirement_set.rb

@@ -0,0 +1,13 @@
+require_relative 'serializer'
+
+module Inferno
+  module Web
+    module Serializers
+      class RequirementSet < Serializer
+        identifier :identifier
+
+        field :title
+      end
+    end
+  end
+end

data/lib/inferno/apps/web/serializers/test_suite.rb

@@ -1,4 +1,5 @@
 require_relative 'preset'
+require_relative 'requirement_set'
 require_relative 'suite_option'
 require_relative 'test_group'
 
@@ -27,6 +28,7 @@ module Inferno
 
         view :full do
           include_view :summary
+
           field :test_groups do |suite, options|
             suite_options = options[:suite_options]
             TestGroup.render_as_hash(suite.groups(suite_options), suite_options:)
@@ -36,6 +38,14 @@ module Inferno
             suite_options = options[:suite_options]
             Input.render_as_hash(suite.available_inputs(suite_options).values)
           end
+          field :requirement_sets, if: :field_present? do |suite, options|
+            selected_options = options[:suite_options] || []
+            requirement_sets = suite.requirement_sets.select do |requirement_set|
+              requirement_set.suite_options.all? { |suite_option| selected_options.include? suite_option }
+            end
+
+            RequirementSet.render_as_hash(requirement_sets)
+          end
         end
       end
     end

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

@@ -0,0 +1,40 @@
+require_relative '../../repositories/requirements'
+
+Inferno::Application.register_provider(:requirements) do
+  prepare do
+    target_container.start :suites
+
+    requirements_repo = Inferno::Repositories::Requirements.new
+
+    test_kit_gems =
+      Bundler
+        .definition
+        .specs
+        .select { |spec| spec.metadata.fetch('inferno_test_kit', 'false').casecmp? 'true' }
+
+    files_to_load = Dir.glob(['lib/*test_kit/requirements/*.csv'])
+
+    if ENV['LOAD_DEV_SUITES'].present?
+      ENV['LOAD_DEV_SUITES'].split(',').map(&:strip).reject(&:empty?).each do |suite|
+        files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'dev_suites', suite, 'requirements',
+                                                '*.csv'))
+      end
+    end
+
+    files_to_load +=
+      test_kit_gems.flat_map do |gem|
+        [
+          Dir.glob([File.join(gem.full_gem_path, 'lib', '*test_kit', 'requirements', '*.csv')])
+        ].flatten
+      end
+
+    files_to_load.compact!
+    files_to_load.reject! { |file| file.include?('out_of_scope') }
+    files_to_load.map! { |path| File.realpath(path) }
+    files_to_load.uniq!
+
+    files_to_load.each do |path|
+      requirements_repo.insert_from_file(path)
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/rules/all_defined_extensions_have_examples.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        class AllDefinedExtensionsHaveExamples < Rule
+          attr_accessor :used_extensions, :unused_extensions
+
+          def check(context)
+            @used_extensions = context.data.map { |e| extension_urls(e) }.flatten.uniq
+            @unused_extensions = []
+
+            get_unused_extensions(context.ig.extensions) do |extension|
+              next true if extension.context.any? do |ctx|
+                # Skip extensions that are defined for definitional artifacts.
+                # For example, US Core's uscdi-requirement extension is applied to
+                # the profiles and extensions of the IG, not data that conforms to the IG.
+                # There may eventually be cases where SD/ED are data, so this may become configurable.
+                ctx.expression == 'StructureDefinition' || ctx.expression == 'ElementDefinition'
+              end
+
+              versioned_url = "#{extension.url}|#{extension.version}"
+              used_extensions.include?(extension.url) || used_extensions.include?(versioned_url)
+            end
+
+            if unused_extensions.any?
+              message = "Found unused extensions defined in the IG: \n\t #{unused_extensions.join(', ')}"
+              result = EvaluationResult.new(message, rule: self)
+            else
+              message = 'All defined extensions are represented in examples'
+              result = EvaluationResult.new(message, severity: 'success', rule: self)
+            end
+
+            context.add_result result
+          end
+
+          def extension_urls(resource)
+            urls = []
+            resource.each_element do |value, _metadata, path|
+              path_elements = path.split('.')
+              next unless path_elements.length > 1
+
+              urls << value if path_elements[-2].include?('extension') && path_elements[-1] == 'url'
+            end
+            urls.uniq
+          end
+
+          def get_unused_extensions(extensions, &extension_filter)
+            extensions.each do |extension|
+              unused_extensions.push extension.url unless extension_filter.call(extension)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/rules/all_extensions_used.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        class AllExtensionsUsed < Rule
+          def check(context)
+            all_extensions = collect_profile_extensions(context.ig.profiles)
+            unused_extensions = remove_found_resource_extensions(all_extensions, context.data)
+            if unused_extensions.any? { |_profile, extensions| !extensions.empty? }
+              message = get_fail_message(unused_extensions)
+              result = EvaluationResult.new(message, rule: self)
+            else
+              message = 'All extensions specified in profiles are represented in instances.'
+              result = EvaluationResult.new(message, severity: 'success', rule: self)
+            end
+
+            context.add_result result
+          end
+
+          def collect_profile_extensions(profiles)
+            extensions = Hash.new { |extension, profile| extension[profile] = Set.new }
+            profiles.each do |profile|
+              profile.each_element do |value, metadata|
+                next unless metadata['type'] == 'ElementDefinition'
+
+                path_end = value.id.split('.')[-1]
+                next unless path_end.include?('extension')
+
+                value.type.each do |element_definition|
+                  element_definition.profile.each do |extension_url|
+                    extensions[profile.url].add(extension_url)
+                  end
+                end
+              end
+            end
+            extensions
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def remove_found_resource_extensions(extensions, examples)
+            unused_extensions = extensions.dup
+            examples.each do |resource|
+              resource.each_element do |value, _metadata, path|
+                path_elements = path.split('.')
+                next unless path_elements.length > 1
+
+                next unless path_elements[-2].include?('extension') && path_elements[-1] == 'url'
+
+                profiles = resource&.meta&.profile || []
+                update_unused_extensions(profiles, value, unused_extensions, extensions)
+              end
+            end
+            unused_extensions
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          def update_unused_extensions(profiles, value, unused_extensions, extensions)
+            profiles.each do |profile|
+              unused_extensions[profile].delete(value) if extensions.key?(profile)
+            end
+          end
+
+          def get_fail_message(extensions)
+            message = 'Found extensions specified in profiles, but not used in instances:'
+            extensions.each do |profile, extension|
+              message += "\n Profile: #{profile}, \n\tExtensions: #{extension.join(', ')}" unless extension.empty?
+            end
+            message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/rules/all_profiles_have_examples.rb

@@ -0,0 +1,49 @@
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        class AllProfilesHaveExamples < Rule
+          include ProfileConformanceHelper
+
+          attr_accessor :context, :unused_profile_urls, :all_resources
+
+          def check(context)
+            @context = context
+            @unused_profile_urls = []
+            @all_resources = []
+            options = context.config.data['Rule']['AllProfilesHaveExamples']['ConformanceOptions'].to_options
+
+            context.data.map { |entry| extract_resources(entry) }
+            all_resources.uniq!
+
+            context.ig.profiles.each do |profile|
+              profile_used = all_resources.any? do |resource|
+                conforms_to_profile?(resource, profile, options, context.validator)
+              end
+              unused_profile_urls << profile.url unless profile_used
+            end
+
+            unused_profile_urls.uniq!
+
+            if unused_profile_urls.any?
+              message = "Found profiles without examples: \n\t #{unused_profile_urls.join(', ')}"
+              result = EvaluationResult.new(message, rule: self)
+            else
+              message = 'All profiles have example instances.'
+              result = EvaluationResult.new(message, severity: 'success', rule: self)
+            end
+
+            context.add_result result
+          end
+
+          def extract_resources(resource)
+            all_resources << resource
+            return unless resource.resourceType == 'Bundle'
+
+            resource.entry.map { |entry| extract_resources(entry.resource) }.flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/rules/all_search_parameters_have_examples.rb

@@ -0,0 +1,79 @@
+require_relative '../../fhirpath_evaluation'
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        class AllSearchParametersHaveExamples < Rule
+          include FhirpathEvaluation
+
+          def check(context)
+            unless ENV['FHIRPATH_URL']
+              message = 'FHIRPATH_URL is not found. Skipping rule AllSearchParametersHaveExamples.'
+              result = EvaluationResult.new(message, severity: 'warning', rule: self)
+              context.add_result result
+              return
+            end
+
+            unused_resource_urls = []
+            search_params = context.ig.resources_by_type['SearchParameter']
+
+            search_params.each do |search_param|
+              unused_resource_urls.push search_param.url unless param_is_used?(search_param, context)
+            end
+
+            if unused_resource_urls.any?
+              message = "Found SearchParameters with no searchable data: \n\t#{unused_resource_urls.join(' ,')}"
+              result = EvaluationResult.new(message, rule: self)
+            elsif !search_params.empty?
+              message = 'All SearchParameters have examples'
+              result = EvaluationResult.new(message, severity: 'success', rule: self)
+            else
+              message = 'IG contains no SearchParameter'
+              result = EvaluationResult.new(message, severity: 'information', rule: self)
+            end
+
+            context.add_result result
+          end
+
+          def param_is_used?(param, context)
+            # Assume that all params have an expression (fhirpath)
+            # This is not guaranteed since the field is 0..1
+            # but without it there's no other way to select a value
+            # Return warning if params don't include expression
+            unless param.expression
+              message = "Search parameter #{param.url} doesn't have an expression."
+              result = EvaluationResult.new(message, severity: 'warning', rule: self)
+              context.add_result result
+              return false
+            end
+
+            used = false
+
+            context.data.each do |resource|
+              next unless param.base.include? resource.resourceType
+
+              begin
+                result = evaluate_fhirpath(resource: resource, path: param.expression)
+              rescue StandardError => e
+                message = "SearchParameter #{param.url} failed to evaluate due to an error. " \
+                          "Expression: #{param.expression}. #{e}"
+                result = EvaluationResult.new(message)
+                context.add_result result
+
+                used = true
+                break
+              end
+
+              if result.present?
+                used = true
+                break
+              end
+            end
+            used
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_evaluation/rules/differential_content_has_examples.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        class DifferentialContentHasExamples < Rule
+          def check(context)
+            unused_differential = Hash.new { |field, url| field[url] = Set.new }
+            collect_profile_differential_content(unused_differential, context.ig.profiles)
+            collect_profile_differential_content(unused_differential, context.ig.extensions)
+            remove_found_differential_content(unused_differential, context.data)
+
+            if unused_differential.any? { |_url, diff| !diff.empty? }
+              message = gen_differential_fail_message(unused_differential)
+              result = EvaluationResult.new(message, rule: self)
+            else
+              message = 'All differential fields are represented in instances'
+              result = EvaluationResult.new(message, severity: 'success', rule: self)
+            end
+
+            context.add_result result
+          end
+
+          def collect_profile_differential_content(unused_differential, profiles)
+            profiles.each do |profile|
+              profile.each_element do |value, _metadata, path|
+                next unless path.start_with? 'differential'
+
+                next unless value.is_a? FHIR::ElementDefinition
+                next unless value.id.include? '.'
+
+                # Skip fields that are disallowed by the profile (cardinality 0..0)
+                # Note that max is a string to allow for "*", not an int
+                next if value.max == '0'
+
+                # TODO: discriminate between extensions
+                # if you have field.extension:A and field.extension:B
+                # only field.extension is recorded and checked for
+                # if A and B are not defined in the IG,they may be missed
+                clean_val = clean_value(value)
+
+                unused_differential[profile.url].add(clean_val)
+              end
+            end
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def remove_found_differential_content(unused_differential, examples)
+            examples.each do |resource|
+              extension_base_path = ''
+              extension_url = ''
+              resource.each_element do |value, _metadata, path|
+                profiles = resource&.meta&.profile || []
+                profiles.each do |profile|
+                  processed_path = plain_value(path)
+                  processed_path = rm_brackets(processed_path)
+
+                  if path.match?('extension\[\d+\]\.url$')
+                    extension_base_path = path.rpartition('.').first
+                    extension_url = value
+                    unused_differential[extension_url].delete('url') if unused_differential.key?(extension_url)
+                    unused_differential[extension_url].delete('extension') if unused_differential.key?(extension_url)
+                    unused_differential.delete(extension_url) if unused_differential[extension_url].empty?
+                  elsif path.start_with?(extension_base_path) && !extension_base_path.empty?
+                    if unused_differential.key?(extension_url)
+                      unused_differential[extension_url].delete(processed_path.rpartition('.').last)
+                    end
+                    unused_differential.delete(extension_url) if unused_differential[extension_url].empty?
+                  else
+                    unused_differential[profile].delete(processed_path) if unused_differential.key?(profile)
+                    unused_differential.delete(profile) if unused_differential[profile].empty?
+                  end
+                end
+              end
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          def clean_value(value)
+            stripped_val = value.id.partition('.').last
+            stripped_val = stripped_val.partition('[').first if stripped_val.end_with? ']'
+            stripped_val.split('.').map do |field|
+              field = field.partition(':').first if field.include?(':')
+              field = field.partition('[').first if field.include?('[')
+              field
+            end.join('.')
+          end
+
+          def plain_value(path)
+            if path.include? '.'
+              path_array = path.split('.').map! do |field|
+                field.start_with?('value') ? 'value' : field
+              end
+              path_array.join('.')
+            elsif path.start_with?('value')
+              'value'
+            elsif path.end_with?(']')
+              path.rpartition('[').first
+            else
+              path
+            end
+          end
+
+          def rm_brackets(path)
+            path_array = path.split('.').map! do |field|
+              field.include?('[') ? field.partition('[').first : field
+            end
+            path_array.join('.')
+          end
+
+          def gen_differential_fail_message(unused_differential)
+            "Found fields highlighted in the differential view, but not used in instances: #{
+                            unused_differential.map do |url, field|
+                              next if field.empty?
+
+                              "\n Profile/Extension: #{url}  \n\tFields: #{field.join(', ')}"
+                            end.compact.join}"
+          end
+        end
+      end
+    end
+  end
+end