inferno_core 0.6.8 → 0.6.10

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 used in examples.'
+              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 examples: #{
+                            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 ValueSets 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 = 'Found ValueSets with all codes used (at least once) in examples:'
+              value_set_used.map { |url| message += "\n\t#{url}" }
+
+              message += "\nFound unused ValueSets: "
+              value_set_unused.map { |url| message += "\n\t#{url}" }
+
+              if value_set_unevaluated.any?
+                message += "\nFound unevaluated ValueSets: "
+                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/fhir_resource_validation.rb

@@ -175,10 +175,10 @@ module Inferno
           begin
             response = call_validator(resource, profile_url)
           rescue StandardError => e
-            # This could be a complete failure to connect (validator isn't running)
-            # or a timeout (validator took too long to respond).
             runnable.add_message('error', e.message)
-            raise Inferno::Exceptions::ErrorInValidatorException, "Unable to connect to validator at #{url}."
+            Application[:logger].error(e.message)
+
+            raise Inferno::Exceptions::ErrorInValidatorException, validator_error_message(e)
           end
 
           outcome = operation_outcome_from_validator_response(response, runnable)
@@ -340,6 +340,28 @@ module Inferno
                 'Validator response was an unexpected format. ' \
                 'Review Messages tab or validator service logs for more information.'
         end
+
+        # Add a specific error message for specific network problems to help the user
+        #
+        # @private
+        # @param error [Exception] An error exception that happened during evaluator connection
+        # @return [String] A readable error message describing the specific network problem
+        def validator_error_message(error)
+          case error
+          when Faraday::ConnectionFailed
+            "Connection failed to validator at #{url}."
+          when Faraday::TimeoutError
+            "Timeout while connecting to validator at #{url}."
+          when Faraday::SSLError
+            "SSL error connecting to validator at #{url}."
+          when Faraday::ClientError  # these are 400s
+            "Client error (4xx) connecting to validator at #{url}."
+          when Faraday::ServerError  # these are 500s
+            "Server error (5xx) from validator at #{url}."
+          else
+            "Unable to connect to validator at #{url}."
+          end
+        end
       end
 
       # @private

data/lib/inferno/dsl/fhirpath_evaluation.rb

@@ -67,7 +67,9 @@ module Inferno
             # This could be a complete failure to connect (fhirpath service isn't running)
             # or a timeout (fhirpath service took too long to respond).
             runnable.add_message('error', e.message)
-            raise Inferno::Exceptions::ErrorInFhirpathException, "Unable to connect to FHIRPath service at #{url}."
+            Application[:logger].error(e.message)
+
+            raise Inferno::Exceptions::ErrorInFhirpathException, evaluator_error_message(e)
           end
 
           sanitized_body = remove_invalid_characters(response.body)
@@ -108,6 +110,28 @@ module Inferno
         def remove_invalid_characters(string)
           string.gsub(/[^[:print:]\r\n]+/, '')
         end
+
+        # Add a specific error message for specific network problems to help the user
+        #
+        # @private
+        # @param error [Exception] An error exception that happened during evaluator connection
+        # @return [String] A readable error message describing the specific network problem
+        def evaluator_error_message(error)
+          case error
+          when Faraday::ConnectionFailed
+            "Connection failed to evaluator at #{url}."
+          when Faraday::TimeoutError
+            "Timeout while connecting to evaluator at #{url}."
+          when Faraday::SSLError
+            "SSL error connecting to evaluator at #{url}."
+          when Faraday::ClientError  # these are 400s
+            "Client error (4xx) connecting to evaluator at #{url}."
+          when Faraday::ServerError  # these are 500s
+            "Server error (5xx) from evaluator at #{url}."
+          else
+            "Unable to connect to FHIRPath service at #{url}."
+          end
+        end
       end
 
       module ClassMethods

data/lib/inferno/dsl/input_output_handling.rb

@@ -12,6 +12,7 @@ module Inferno
       # @option input_params [String] :default The default value for the input
       # @option input_params [Boolean] :optional Set to true to not require input for test execution
       # @option input_params [Boolean] :locked If true, the user can not alter the value
+      # @option input_params [Boolean] :hidden If true, the input will not be visible to the user in the UI
       # @option input_params [Hash] :options Possible input option formats based on input type
       # @option options [Array] :list_options Array of options for input formats
       #   that require a list of possible values (radio and checkbox)

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]
@@ -331,6 +346,11 @@ module Inferno
         @all_children ||= []
       end
 
+      # @private
+      def all_descendants
+        children.flat_map { |child| [child] + child.all_descendants }
+      end
+
       # @private
       def suite
         return self if ancestors.include? Inferno::Entities::TestSuite
@@ -550,6 +570,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? '#' }