inferno_core 0.6.8 → 0.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6daa4c1864a7e7004ca9a166f3e516fcddc157c3f6b6e24722965e44330cc450
-  data.tar.gz: b158c90f63eaa8a157a27b92af68b7a3be7798e18aca2243ecbd1071c9d9bfdf
+  metadata.gz: 5740a0c7e8d54767851b4f7e9ee7c5c6ca9ac175211d63b4990f99bbbe9266ca
+  data.tar.gz: 4fd1b9c5cb4f37c441a668ae58c8b6cd49aeea18ad393b2d7bbb9699d86a0060
 SHA512:
-  metadata.gz: 6298ba6c1f61a6ee3f5e50045ac58e1ebaa63a2ebc863755d1c610d3eed4b0e7ca76ea74ee12c506298624248c5f3b874582eaccc1c41600f731b33a601d72ce
-  data.tar.gz: 61f9b65616cf01dd42c838ab0b9be5c38490dea22bb2a3481a82c30a25c687e2aada97321498920f6219a62afe88445ad95e71b2300859fce5ed19af7cef1f78
+  metadata.gz: f6adc91f5db1ba2a6535c847c0fe7b691cd85455fb0f34a44bd525428dee3ddcd4c414d7989ea4e13fdd50b9c39778a19d26e97473f1617b85691b4683776f49
+  data.tar.gz: 463d68cf3e187f992bd134bbc177072bfaa9ec625a2006ca1bb23c49591a4bc9521ca027232c68c5d1ebcf499dcca84f3f722ca2afd9bd1b6038bbb19daf4835

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_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/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

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'base64'
+
+module Inferno
+  module DSL
+    module FHIREvaluation
+      module Rules
+        # This rule evaluates if an IG defines a new valueset, the examples should
+        # demonstrate reasonable coverage of that valueset.
+        # Note this probably only makes sense for small valuesets
+        # such as status options, not something like disease codes from SNOMED.
+
+        # Algorithm:
+        # 1. Extract pairs of system and code from include in value sets in IG
+        # 2. If valueSet exists in include, retrieve the value sets from UMLS.
+        #    Extract pairs of system and code from the result.
+        # 3. For each pair of system and code, check if any resources in the IG have instance of them.
+        # 4. Count total number of existences.
+
+        class ValueSetsDemonstrate < Rule
+          attr_accessor :config, :value_set_unevaluated, :value_set_used, :value_set_unused
+
+          def check(context)
+            @config = context.config
+            @value_set_used = []
+            @value_set_unused = []
+            @value_set_unevaluated = []
+
+            classify_valuesets(context)
+
+            context.add_result create_result_message
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def classify_valuesets(context)
+            context.ig.value_sets.each do |valueset|
+              valueset_used_count = 0
+              system_codes = extract_systems_codes_from_valueset(valueset)
+
+              value_set_unevaluated << "#{valueset.url}: unable to find system and code" if system_codes.none?
+              value_set_unevaluated.uniq!
+
+              next if value_set_unevaluated.any? { |element| element.include?(valueset.url) }
+
+              resource_used = []
+
+              context.data.each do |resource|
+                system_codes.each do |system_code|
+                  next unless !system_code.nil? && resource_uses_code(resource.to_hash, system_code[:system],
+                                                                      system_code[:code])
+
+                  valueset_used_count += 1
+                  resource_used << resource.id unless resource_used.include?(resource.id)
+                end
+              end
+
+              if valueset_used_count.positive?
+                # rubocop:disable Layout/LineLength
+                value_set_used << "#{valueset.url} is used #{valueset_used_count} times in #{resource_used.count} resources"
+                # rubocop:enable Layout/LineLength
+              else
+                value_set_unused << valueset.url
+              end
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def create_result_message
+            if value_set_unused.none?
+              message = 'All Value sets are used in Examples:'
+              value_set_used.map { |value_set| message += "\n\t#{value_set}" }
+
+              if value_set_unevaluated.any?
+                message += "\nThe following Value Sets were not able to be evaluated: "
+                value_set_unevaluated.map { |value_set| message += "\n\t#{value_set}" }
+              end
+
+              EvaluationResult.new(message, severity: 'success', rule: self)
+            else
+              message = 'Value sets with all codes used at least once in Examples:'
+              value_set_used.map { |url| message += "\n\t#{url}" }
+
+              message += "\nFound unused Value Sets: "
+              value_set_unused.map { |url| message += "\n\t#{url}" }
+
+              if value_set_unevaluated.any?
+                message += "\nFound unevaluated Value Sets: "
+                value_set_unevaluated.map { |url| message += "\n\t#{url}" }
+              end
+
+              EvaluationResult.new(message, rule: self)
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def extract_systems_codes_from_valueset(valueset)
+            system_codes = []
+
+            if valueset.to_hash['compose']
+              valueset.to_hash['compose']['include'].each do |include|
+                if include['valueSet']
+                  include['valueSet'].each do |url|
+                    retrieve_valueset_from_api(url)&.each { |system_code| system_codes << system_code }
+                  end
+                  next
+                end
+
+                system_url = include['system']
+
+                if system_url && include['concept']
+                  include['concept'].each do |code|
+                    system_codes << { system: system_url, code: code.to_hash['code'] }
+                  end
+                  next
+                end
+
+                if system_url
+                  if system_url['http://hl7.org/fhir']
+                    retrieve_valueset_from_api(system_url)&.each { |vs| system_codes << vs }
+                  end
+                  next
+                end
+
+                value_set_unevaluated << "#{valueset.url}: system url not provided" unless system_url
+
+                # Exclude if system is provided as Uniform Resource Name "urn:"
+                # Exclude filter
+                # Exclude only system is provided (e.g. http://loing.org)
+                exclusions = config.data['Rule']['ValueSetsDemonstrate']['Exclude']
+                if exclusions['URL'] && (system_url['urn'])
+                  value_set_unevaluated << "#{valueset.url}: unable to handle Uniform Resource Name"
+                end
+
+                if exclusions['Filter'] && (system_url && include['filter'])
+                  value_set_unevaluated << "#{valueset.url}: unable to handle filter"
+                end
+
+                if exclusions['SystemOnly'] && (system_url && !include['concept'] && !include['filter'])
+                  value_set_unevaluated << "#{valueset.url}: unabe to handle SystemOnly"
+                end
+              end
+            else
+              value_set_unevaluated << valueset.url
+            end
+            system_codes.flatten.uniq
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def resource_uses_code(resource, system, code)
+            resource.each do |key, value|
+              next unless key == 'code' || ['value', 'valueCodeableConcept', 'valueString',
+                                            'valueQuantity', 'valueBoolean',
+                                            'valueInteger', 'valueRange', 'valueRatio',
+                                            'valueSampleData', 'valueDateTime',
+                                            'valuePeriod', 'valueTime'].include?(key)
+              next unless value.is_a?(Hash)
+
+              value['coding']&.each do |codeset|
+                return true if codeset.to_hash['system'] == system && codeset.to_hash['code'] == code
+              end
+            end
+
+            false
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          def extract_valueset_from_response(response)
+            value_set = JSON.parse(response.body)
+
+            if value_set['compose'] && value_set['compose']['include']
+              value_set['compose']['include'].map do |include|
+                include['concept']&.map { |concept| { system: include['system'], code: concept['code'] } }
+              end.flatten
+            else
+              puts 'No Value Set found in the response.'
+            end
+          end
+
+          def retrieve_valueset_from_api(url)
+            url['http:'] = 'https:' if url['http:']
+            uri = URI.parse(url)
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = (uri.scheme == 'https')
+
+            request = Net::HTTP::Get.new(uri.request_uri)
+
+            username = config.data['Environment']['VSAC']['Username']
+            password = config.data['Environment']['VSAC']['Password']
+            encoded_credentials = Base64.strict_encode64("#{username}:#{password}")
+            request['Authorization'] = "Basic #{encoded_credentials}"
+
+            response = http.request(request)
+
+            content_type = response['content-type']
+            return unless content_type && !content_type.include?('text/html')
+
+            while response.is_a?(Net::HTTPRedirection)
+              redirect_url = response['location']
+
+              redirect_url['xml'] = 'json'
+              uri = URI.parse(redirect_url)
+
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = (uri.scheme == 'https')
+
+              response = http.request(Net::HTTP::Get.new(uri.request_uri))
+            end
+
+            if response.code.to_i == 200
+              extract_valueset_from_response(response)
+            else
+              unless config.data['Rule']['ValueSetsDemonstrate']['IgnoreUnloadableValueset']
+                raise StandardError, "Failed to retrieve external value set: #{url} HTTP Status code: #{response.code}"
+              end
+
+              value_set_unevaluated << "#{url}: Failed to retrieve. HTTP Status code: #{response.code}"
+              nil
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_resource_navigation.rb

@@ -177,8 +177,17 @@ module Inferno
       end
 
       def matching_required_binding_slice?(slice, discriminator)
-        discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
-        slice_value { |coding| discriminator[:values].include?(coding.code) }
+        slice_coding = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+        slice_coding.any? do |coding|
+          discriminator[:values].any? do |value|
+            case value
+            when String
+              value == coding.code
+            when Hash
+              value[:system] == coding.system && value[:code] == coding.code
+            end
+          end
+        end
       end
 
       def verify_slice_by_values(element, value_definitions)

data/lib/inferno/dsl/must_support_assessment.rb

@@ -332,18 +332,23 @@ module Inferno
           when 'Date'
             begin
               Date.parse(element)
-            rescue ArgumentError
+            rescue ArgumentError, TypeError
               false
             end
           when 'DateTime'
             begin
               DateTime.parse(element)
-            rescue ArgumentError
+            rescue ArgumentError, TypeError
               false
             end
           when 'String'
             element.is_a? String
           else
+            if element.is_a? FHIR::Bundle::Entry
+              # Special case for type slicing in a Bundle - look at the resource not the entry
+              element = element.resource
+            end
+
             element.is_a? FHIR.const_get(discriminator[:code])
           end
         end
@@ -352,7 +357,14 @@ module Inferno
           coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
 
           find_a_value_at(element, coding_path) do |coding|
-            discriminator[:values].any? { |value| value[:system] == coding.system && value[:code] == coding.code }
+            discriminator[:values].any? do |value|
+              case value
+              when String
+                value == coding.code
+              when Hash
+                value[:system] == coding.system && value[:code] == coding.code
+              end
+            end
           end
         end
 

data/lib/inferno/dsl/requirement_set.rb

@@ -0,0 +1,82 @@
+module Inferno
+  module DSL
+    # A `RequirementSet` represents the set of requirements which are tested by
+    # a TestSuite.
+    #
+    # @!attribute identifier [rw] The unique identifier for the source of
+    #   requirements included in this `RequirementSet`
+    # @!attribute title [rw] A human-readable title for this `RequirementSet`
+    # @!attribute actor [rw] The actor whose requirements are included in this
+    #   `RequirementSet`
+    # @!attribute requirements [rw] There are three options:
+    #   * `"all"` (default) - Include all of the requirements for the specified
+    #     actor from the requirement source
+    #   * `"referenced"` - Only include requirements from this source if they
+    #     are referenced by other included requirements
+    #   * `"1,3,5-8"` - Only include the requirements from a comma-delimited
+    #     list
+    # @!attribute suite_options [rw] A set of suite options which must be
+    #   selected in order for this `RequirementSet` to be included
+    #
+    # @see Inferno::DSL::SuiteRequirements#requirement_sets
+    class RequirementSet
+      ATTRIBUTES = [
+        :identifier,
+        :title,
+        :actor,
+        :requirements,
+        :suite_options
+      ].freeze
+
+      include Entities::Attributes
+
+      def initialize(raw_attributes_hash)
+        attributes_hash = raw_attributes_hash.symbolize_keys
+
+        invalid_keys = attributes_hash.keys - ATTRIBUTES
+
+        raise Exceptions::UnknownAttributeException.new(invalid_keys, self.class) if invalid_keys.present?
+
+        attributes_hash.each do |name, value|
+          if name == :suite_options
+            value = value&.map { |option_id, option_value| SuiteOption.new(id: option_id, value: option_value) }
+          end
+
+          instance_variable_set(:"@#{name}", value)
+        end
+
+        self.suite_options ||= []
+      end
+
+      # Returns true when the `RequirementSet` includes all of the requirements
+      # from the source for the specified actor
+      #
+      # @return [Boolean]
+      def complete?
+        requirements.blank? || requirements.casecmp?('all')
+      end
+
+      # Returns true when the `RequirementSet` only includes requirements
+      # referenced by other `RequirementSet`s
+      #
+      # @return [Boolean]
+      def referenced?
+        requirements&.casecmp? 'referenced'
+      end
+
+      # Returns true when the `RequirementSet` only includes requirements
+      # specified in a list
+      #
+      # @return [Boolean]
+      def filtered?
+        !complete? && !referenced?
+      end
+
+      # Expands the compressed comma-separated requirements list into an Array
+      # of full ids
+      def expand_requirement_ids
+        Entities::Requirement.expand_requirement_ids(requirements, identifier)
+      end
+    end
+  end
+end

data/lib/inferno/dsl/runnable.rb

@@ -276,6 +276,21 @@ module Inferno
         @input_instructions = format_markdown(new_input_instructions)
       end
 
+      # Set/Get the IDs of requirements verified by this runnable
+      # Set with [] to clear the list
+      #
+      # @param requirements [Array<String>]
+      # @return [Array<String>] the requirement IDs
+      def verifies_requirements(*requirement_ids)
+        if requirement_ids.empty?
+          @requirement_ids || []
+        elsif requirement_ids == [[]]
+          @requirement_ids = []
+        else
+          @requirement_ids = requirement_ids
+        end
+      end
+
       # Mark as optional. Tests are required by default.
       #
       # @param optional [Boolean]
@@ -550,6 +565,13 @@ module Inferno
         end
       end
 
+      # @private
+      def all_requirements(suite_options = [])
+        children(suite_options).flat_map do |child|
+          child.verifies_requirements + child.all_requirements(suite_options)
+        end
+      end
+
       # @private
       def inspect
         non_dynamic_ancestor = ancestors.find { |ancestor| !ancestor.to_s.start_with? '#' }

data/lib/inferno/dsl/suite_requirements.rb

@@ -0,0 +1,46 @@
+require_relative 'requirement_set'
+
+module Inferno
+  module DSL
+    module SuiteRequirements
+      # Get/Set the sets of requirments tested by a suite.
+      #
+      # @param sets [Array<Inferno::DSL::RequirementSet>]
+      # @return [Array<Inferno::DSL::RequirementSet>]
+      #
+      # @example
+      # class Suite < Inferno::TestSuite
+      #   requirement_sets(
+      #     {
+      #       identifier: 'example-regulation-1',
+      #       title: 'Example Regulation 1',
+      #       actor: 'Provider' # Only include requirements for the 'Provider'
+      #                         # actor
+      #     },
+      #     {
+      #       identifier: 'example-ig-1',
+      #       title: 'Example Implementation Guide 1',
+      #       actor: 'Provider',
+      #       requirements: '2, 4-5' # Only include these specific requirements
+      #     },
+      #     {
+      #       identifier: 'example-ig-2',
+      #       title: 'Example Implementation Guide 2',
+      #       requirements: 'Referenced', # Only include requirements from this
+      #                                   # set that are referenced by other
+      #                                   # included requirements
+      #       actor: 'Server',
+      #       suite_options: {      # Only include these requirements if the ig
+      #         ig_version: '3.0.0' # version 3.0.0 suite option is selected
+      #       }
+      #     }
+      #   )
+      # end
+      def requirement_sets(*sets)
+        @requirement_sets = sets.map { |set| RequirementSet.new(**set) } if sets.present?
+
+        @requirement_sets || []
+      end
+    end
+  end
+end

data/lib/inferno/entities/ig.rb

@@ -126,6 +126,10 @@ module Inferno
         "#{ig_resource.id}##{ig_resource.version || 'current'}"
       end
 
+      def value_sets
+        resources_by_type['ValueSet']
+      end
+
       def profiles
         resources_by_type['StructureDefinition'].filter { |sd| sd.type != 'Extension' }
       end

data/lib/inferno/entities/requirement.rb

@@ -0,0 +1,63 @@
+require_relative 'attributes'
+require_relative 'entity'
+
+module Inferno
+  module Entities
+    # A `Requirement` represents the specific rule or behavior a runnable is testing.
+    class Requirement < Entity
+      ATTRIBUTES = [
+        :id,
+        :requirement_set,
+        :url,
+        :requirement,
+        :conformance,
+        :actor,
+        :sub_requirements,
+        :conditionality
+      ].freeze
+
+      include Inferno::Entities::Attributes
+
+      def initialize(params)
+        super(params, ATTRIBUTES)
+
+        self.requirement_set = id.split('@').first if requirement_set.blank? && id&.include?('@')
+      end
+
+      # Expand a comma-delimited list of requirement id references into an Array
+      # of full requirement ids
+      #
+      # @param requirement_id_string [String] A comma-delimited list of
+      #   requirement id references
+      # @param default_set [String] The requirement set identifier which will be
+      #   used if none is included in the `requirement_id_string`
+      #
+      # @example
+      # expand_requirement_ids('example-ig@1,3,5-7')
+      # # => ['example-ig@1','example-ig@3','example-ig@5','example-ig@6','example-ig@7']
+      # expand_requirement_ids('1,3,5-7', 'example-ig')
+      # # => ['example-ig@1','example-ig@3','example-ig@5','example-ig@6','example-ig@7']
+      def self.expand_requirement_ids(requirement_id_string, default_set = nil)
+        return [] if requirement_id_string.blank?
+
+        current_set = default_set
+        requirement_id_string
+          .split(',')
+          .map(&:strip)
+          .flat_map do |requirement_string|
+            current_set, requirement_string = requirement_string.split('@') if requirement_string.include?('@')
+
+            requirement_ids =
+              if requirement_string.include? '-'
+                start_id, end_id = requirement_string.split('-')
+                (start_id..end_id).to_a
+              else
+                [requirement_string]
+              end
+
+            requirement_ids.map { |id| "#{current_set}@#{id}" }
+          end
+      end
+    end
+  end
+end

data/lib/inferno/entities/test_suite.rb

@@ -1,6 +1,7 @@
 require_relative 'test_group'
 require_relative '../dsl/runnable'
 require_relative '../dsl/suite_option'
+require_relative '../dsl/suite_requirements'
 require_relative '../dsl/messages'
 require_relative '../dsl/links'
 require_relative '../repositories/test_groups'
@@ -16,6 +17,7 @@ module Inferno
       extend DSL::Links
       extend DSL::FHIRClient::ClassMethods
       extend DSL::HTTPClient::ClassMethods
+      extend DSL::SuiteRequirements
       include DSL::FHIRValidation
       include DSL::FHIRResourceValidation
       include DSL::FhirpathEvaluation

data/lib/inferno/repositories/igs.rb

@@ -18,8 +18,7 @@ module Inferno
       def find_or_load(id_or_path)
         return find(id_or_path) if exists?(id_or_path)
 
-        ig_by_path = find_by_path(id_or_path)
-
+        ig_by_path = find_by_path(id_or_path) || find_by_path(find_local_file(id_or_path))
         return ig_by_path if ig_by_path
 
         load(id_or_path)

data/lib/inferno/repositories/requirements.rb

@@ -0,0 +1,116 @@
+require 'csv'
+require_relative 'in_memory_repository'
+require_relative '../entities/requirement'
+
+module Inferno
+  module Repositories
+    # Repository that deals with persistence for the `Requirement` entity.
+    class Requirements < InMemoryRepository
+      def insert_from_file(path)
+        result = []
+
+        CSV.foreach(path, headers: true, header_converters: :symbol) do |row|
+          req_set = row[:req_set]
+          id = row[:id]
+          sub_requirements_field = row[:subrequirements]
+
+          combined_id = "#{req_set}@#{id}"
+
+          # Processing sub requirements: e.g. "170.315(g)(31)_hti-2-proposal@5,17,23,26,27,32,35,38-41"
+          sub_requirements = Inferno::Entities::Requirement.expand_requirement_ids(sub_requirements_field)
+
+          result << {
+            requirement_set: req_set,
+            id: combined_id,
+            url: row[:url],
+            requirement: row[:requirement],
+            conformance: row[:conformance],
+            actor: row[:actor],
+            sub_requirements: sub_requirements,
+            conditionality: row[:conditionality]&.downcase
+          }
+        end
+
+        result.each do |raw_req|
+          requirement = Entities::Requirement.new(raw_req)
+
+          insert(requirement)
+        end
+      end
+
+      def filter_requirements_by_ids(ids)
+        all.select { |requirement| ids.include?(requirement.id) }
+      end
+
+      def requirements_for_suite(test_suite_id, test_session_id = nil)
+        test_suite = Inferno::Repositories::TestSuites.new.find(test_suite_id)
+        selected_suite_options =
+          if test_session_id.present?
+            Inferno::Repositories::TestSessions.new.find(test_session_id).suite_options
+          else
+            []
+          end
+
+        requirement_sets =
+          test_suite
+            .requirement_sets
+            .select do |set|
+              set.suite_options.all? { |set_option| selected_suite_options.include? set_option }
+            end
+
+        requirements =
+          complete_requirement_set_requirements(requirement_sets) +
+          filtered_requirement_set_requirements(requirement_sets)
+
+        add_referenced_requirement_set_requirements(requirements, requirement_sets).uniq
+      end
+
+      def complete_requirement_set_requirements(requirement_sets)
+        requirement_sets.select(&:complete?)
+          .flat_map do |requirement_set|
+            all.select do |requirement|
+              requirement.requirement_set == requirement_set.identifier && requirement.actor == requirement_set.actor
+            end
+          end
+      end
+
+      def filtered_requirement_set_requirements(requirement_sets)
+        requirement_sets.select(&:filtered?)
+          .flat_map do |requirement_set|
+            requirement_set
+              .expand_requirement_ids
+              .map { |requirement_id| find(requirement_id) }
+              .select { |requirement| requirement.actor == requirement_set.actor }
+          end
+      end
+
+      def add_referenced_requirement_set_requirements( # rubocop:disable Metrics/CyclomaticComplexity
+        requirements_to_process,
+        requirement_sets,
+        processed_requirements = []
+      )
+        return processed_requirements if requirements_to_process.blank?
+
+        referenced_requirement_sets = requirement_sets.select(&:referenced?)
+
+        referenced_requirement_ids =
+          requirements_to_process
+            .flat_map(&:sub_requirements)
+            .select do |requirement_id|
+              referenced_requirement_sets.any? do |set|
+                requirement_id.start_with?("#{set.identifier}@") && (find(requirement_id).actor == set.actor)
+              end
+            end
+
+        new_requirements =
+          referenced_requirement_ids.map { |id| find(id) } - requirements_to_process - processed_requirements
+
+        add_referenced_requirement_set_requirements(
+          new_requirements,
+          referenced_requirement_sets,
+          (processed_requirements + requirements_to_process).uniq
+        )
+      end
+    end
+  end
+end

data/lib/inferno/version.rb

@@ -1,4 +1,4 @@
 module Inferno
   # Standard patterns for gem versions: https://guides.rubygems.org/patterns/
-  VERSION = '0.6.8'.freeze
+  VERSION = '0.6.9'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferno_core
 version: !ruby/object:Gem::Version
-  version: 0.6.8
+  version: 0.6.9
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 2025-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -465,6 +465,7 @@ files:
 - lib/inferno/apps/web/application.rb
 - lib/inferno/apps/web/controllers/controller.rb
 - lib/inferno/apps/web/controllers/requests/show.rb
+- lib/inferno/apps/web/controllers/requirements/show.rb
 - lib/inferno/apps/web/controllers/test_runs/create.rb
 - lib/inferno/apps/web/controllers/test_runs/destroy.rb
 - lib/inferno/apps/web/controllers/test_runs/results/index.rb
@@ -479,6 +480,7 @@ files:
 - lib/inferno/apps/web/controllers/test_sessions/show.rb
 - lib/inferno/apps/web/controllers/test_suites/check_configuration.rb
 - lib/inferno/apps/web/controllers/test_suites/index.rb
+- lib/inferno/apps/web/controllers/test_suites/requirements/index.rb
 - lib/inferno/apps/web/controllers/test_suites/show.rb
 - lib/inferno/apps/web/index.html.erb
 - lib/inferno/apps/web/router.rb
@@ -489,6 +491,8 @@ files:
 - lib/inferno/apps/web/serializers/message.rb
 - lib/inferno/apps/web/serializers/preset.rb
 - lib/inferno/apps/web/serializers/request.rb
+- lib/inferno/apps/web/serializers/requirement.rb
+- lib/inferno/apps/web/serializers/requirement_set.rb
 - lib/inferno/apps/web/serializers/result.rb
 - lib/inferno/apps/web/serializers/serializer.rb
 - lib/inferno/apps/web/serializers/session_data.rb
@@ -505,6 +509,7 @@ files:
 - lib/inferno/config/boot/ig_files.rb
 - lib/inferno/config/boot/logging.rb
 - lib/inferno/config/boot/presets.rb
+- lib/inferno/config/boot/requirements.rb
 - lib/inferno/config/boot/sidekiq.rb
 - lib/inferno/config/boot/suites.rb
 - lib/inferno/config/boot/validator.rb
@@ -535,11 +540,14 @@ files:
 - lib/inferno/dsl/fhir_evaluation/reference_extractor.rb
 - lib/inferno/dsl/fhir_evaluation/rule.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_defined_extensions_have_examples.rb
+- lib/inferno/dsl/fhir_evaluation/rules/all_extensions_used.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_must_supports_present.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_profiles_have_examples.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_references_resolve.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_resources_reachable.rb
 - lib/inferno/dsl/fhir_evaluation/rules/all_search_parameters_have_examples.rb
+- lib/inferno/dsl/fhir_evaluation/rules/differential_content_has_examples.rb
+- lib/inferno/dsl/fhir_evaluation/rules/value_sets_demonstrate.rb
 - lib/inferno/dsl/fhir_resource_navigation.rb
 - lib/inferno/dsl/fhir_resource_validation.rb
 - lib/inferno/dsl/fhir_validation.rb
@@ -556,11 +564,13 @@ files:
 - lib/inferno/dsl/oauth_credentials.rb
 - lib/inferno/dsl/primitive_type.rb
 - lib/inferno/dsl/request_storage.rb
+- lib/inferno/dsl/requirement_set.rb
 - lib/inferno/dsl/results.rb
 - lib/inferno/dsl/resume_test_route.rb
 - lib/inferno/dsl/runnable.rb
 - lib/inferno/dsl/suite_endpoint.rb
 - lib/inferno/dsl/suite_option.rb
+- lib/inferno/dsl/suite_requirements.rb
 - lib/inferno/dsl/tcp_exception_handler.rb
 - lib/inferno/dsl/value_extractor.rb
 - lib/inferno/entities.rb
@@ -573,6 +583,7 @@ files:
 - lib/inferno/entities/message.rb
 - lib/inferno/entities/preset.rb
 - lib/inferno/entities/request.rb
+- lib/inferno/entities/requirement.rb
 - lib/inferno/entities/result.rb
 - lib/inferno/entities/session_data.rb
 - lib/inferno/entities/test.rb
@@ -607,6 +618,7 @@ files:
 - lib/inferno/repositories/presets.rb
 - lib/inferno/repositories/repository.rb
 - lib/inferno/repositories/requests.rb
+- lib/inferno/repositories/requirements.rb
 - lib/inferno/repositories/results.rb
 - lib/inferno/repositories/session_data.rb
 - lib/inferno/repositories/tags.rb