inferno_core 0.6.7 → 0.6.9

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