davinci_plan_net_test_kit 0.9.0

data/lib/davinci_plan_net_test_kit/generator.rb

@@ -0,0 +1,143 @@
+require 'fhir_models'
+require 'inferno/ext/fhir_models'
+
+require_relative 'generator/ig_loader'
+require_relative 'generator/ig_metadata_extractor'
+require_relative 'generator/group_generator'
+require_relative 'generator/must_support_test_generator'
+require_relative 'generator/revinclude_search_test_generator'
+require_relative 'generator/reverse_chain_search_test_generator'
+require_relative 'generator/include_search_test_generator'
+require_relative 'generator/read_test_generator'
+require_relative 'generator/reference_resolution_test_generator'
+require_relative 'generator/resource_list_generator'
+require_relative 'generator/search_test_generator'
+require_relative 'generator/search_no_params_test_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/validation_test_generator'
+require_relative 'generator/forward_chain_test_generator'
+require_relative 'generator/combination_search_test_generator'
+require_relative 'generator/special_cases'
+
+module DaVinciPlanNetTestKit
+  class Generator
+    def self.generate
+      ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'davinci_plan_net_test_kit', 'igs', '*.tgz'))
+
+      ig_packages.each do |ig_package|
+        new(ig_package).generate
+      end
+    end
+
+    attr_accessor :ig_resources, :ig_metadata, :ig_file_name
+
+    def initialize(ig_file_name)
+      self.ig_file_name = ig_file_name
+    end
+
+    def generate
+      puts "Generating tests for IG #{File.basename(ig_file_name)}"
+      load_ig_package
+      extract_metadata
+      generate_resource_list
+      generate_search_no_params_tests
+      generate_read_tests
+      generate_search_tests
+      # TODO: generate_vread_tests
+      # TODO: generate_history_tests
+      generate_include_search_tests
+      generate_revinclude_search_tests
+      generate_forward_chain_search_tests
+      generate_reverse_chain_search_tests
+      generate_combination_chain_search_tests
+      generate_validation_tests
+      generate_must_support_tests
+      generate_reference_resolution_tests
+
+      generate_groups
+
+      generate_suites
+    end
+
+    def extract_metadata
+      self.ig_metadata = IGMetadataExtractor.new(ig_resources).extract
+      
+      # Specific corrections 
+      SpecialCases.run_special_cases(ig_metadata)
+
+      FileUtils.mkdir_p(base_output_dir)
+      File.open(File.join(base_output_dir, 'metadata.yml'), 'w') do |file|
+        file.write(YAML.dump(ig_metadata.to_hash))
+      end
+    end
+
+    def base_output_dir
+      File.join(__dir__, 'generated', ig_metadata.ig_version)
+    end
+
+    def load_ig_package
+      FHIR.logger = Logger.new('/dev/null')
+      self.ig_resources = IGLoader.new(ig_file_name).load
+    end
+
+    def generate_resource_list
+      ResourceListGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_reference_resolution_tests
+      ReferenceResolutionTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_must_support_tests
+      MustSupportTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_validation_tests
+      ValidationTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_read_tests
+      ReadTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_search_tests
+      SearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_search_no_params_tests
+      SearchNoParamsTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_include_search_tests
+      IncludeSearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_revinclude_search_tests
+      RevincludeSearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_reverse_chain_search_tests
+      examples = File.read('lib/davinci_plan_net_test_kit/custom_groups/reverse_chain_tests/examples.json')
+      examples_hash = JSON.parse(examples)
+      ReverseChainSearchTestGenerator.generate(ig_metadata, examples_hash, base_output_dir)
+    end
+
+    def generate_forward_chain_search_tests
+      ForwardChainSearchTestGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_combination_chain_search_tests
+      examples = File.read('lib/davinci_plan_net_test_kit/custom_groups/combination_searches/examples.json')
+      examples_hash = JSON.parse(examples)
+      CombinationSearchTestGenerator.generate(ig_metadata, examples_hash, base_output_dir)
+    end
+    
+    def generate_groups
+      GroupGenerator.generate(ig_metadata, base_output_dir)
+    end
+
+    def generate_suites
+      SuiteGenerator.generate(ig_metadata, base_output_dir)
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/igs/package/SearchParameter-Resource-id.json

@@ -0,0 +1 @@
+{"resourceType":"SearchParameter","id":"Resource-id","extension":[{"url":"http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status","valueCode":"trial-use"}],"url":"http://hl7.org/fhir/SearchParameter/Resource-id","version":"4.0.1","name":"_id","status":"draft","experimental":false,"date":"2019-11-01T09:29:23+11:00","publisher":"Health Level Seven International (FHIR Infrastructure)","contact":[{"telecom":[{"system":"url","value":"http://hl7.org/fhir"}]},{"telecom":[{"system":"url","value":"http://www.hl7.org/Special/committees/fiwg/index.cfm"}]}],"description":"Logical id of this artifact","code":"_id","base":["Resource"],"type":"token","expression":"Resource.id","xpath":"f:Resource/f:id","xpathUsage":"normal"}

data/lib/davinci_plan_net_test_kit/igs/package/SearchParameter-Resource-lastUpdated.json

@@ -0,0 +1 @@
+{"resourceType":"SearchParameter","id":"Resource-lastUpdated","extension":[{"url":"http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status","valueCode":"trial-use"}],"url":"http://hl7.org/fhir/SearchParameter/Resource-lastUpdated","version":"4.0.1","name":"_lastUpdated","status":"draft","experimental":false,"date":"2019-11-01T09:29:23+11:00","publisher":"Health Level Seven International (FHIR Infrastructure)","contact":[{"telecom":[{"system":"url","value":"http://hl7.org/fhir"}]},{"telecom":[{"system":"url","value":"http://www.hl7.org/Special/committees/fiwg/index.cfm"}]}],"description":"When the resource version last changed","code":"_lastUpdated","base":["Resource"],"type":"date","expression":"Resource.meta.lastUpdated","xpath":"f:Resource/f:meta/f:lastUpdated","xpathUsage":"normal","comparator":["eq","ne","gt","ge","lt","le","sa","eb","ap"]}

data/lib/davinci_plan_net_test_kit/must_support_test.rb

@@ -0,0 +1,211 @@
+require_relative 'fhir_resource_navigation'
+
+module DaVinciPlanNetTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all]
+    end
+
+    def perform_must_support_test(resources)
+      skip_if resources.blank?, "No #{resource_type} resources were found"
+
+      missing_elements(resources)
+      missing_slices(resources)
+      missing_extensions(resources)
+
+      handle_must_support_choices if metadata.must_supports[:choices].present?
+
+      if (missing_elements + missing_slices + missing_extensions).length.zero?
+        pass
+      end
+
+      skip "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
+           "provided #{resource_type} resource(s)"
+    end
+
+    def handle_must_support_choices
+      missing_elements.delete_if do |element|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_extensions.delete_if do |extension|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_slices.delete_if do |slice|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
+        is_any_choice_supported?(choices)
+      end
+    end
+
+    def is_any_choice_supported? (choices)
+      choices.present? &&
+      (
+        choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
+        choices[:extension_ids]&.any? { |extension_id| missing_extensions.none? { |extension| extension[:id] == extension_id} } ||
+        choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name} }
+      )
+    end
+
+    def missing_must_support_strings
+      missing_elements.map { |element_definition| missing_element_string(element_definition) } +
+        missing_slices.map { |slice_definition| slice_definition[:name] } +
+        missing_extensions.map { |extension_definition| extension_definition[:id] }
+    end
+
+    def missing_element_string(element_definition)
+      if element_definition[:fixed_value].present?
+        "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
+      else
+        element_definition[:path]
+      end
+    end
+
+    def exclude_uscdi_only_test?
+      config.options[:exclude_uscdi_only_test] == true
+    end
+
+    def must_support_extensions
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:extensions].reject{ |extension| extension[:uscdi_only] }
+      else
+        metadata.must_supports[:extensions]
+      end
+    end
+
+    def missing_extensions(resources = [])
+      @missing_extensions ||=
+        must_support_extensions.select do |extension_definition|
+          resources.none? do |resource|
+            resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+          end
+        end
+    end
+
+    def must_support_elements
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:elements].reject{ |element| element[:uscdi_only] }
+      else
+        metadata.must_supports[:elements]
+      end
+    end
+
+    def missing_elements(resources = [])
+      @missing_elements ||=
+        must_support_elements.select do |element_definition|
+          resources.none? do |resource|
+            path = element_definition[:path] #.delete_suffix('[x]')
+            value_found = find_a_value_at(resource, path) do |value|
+              value_without_extensions =
+                value.respond_to?(:to_hash) ? value.to_hash.reject { |key, _| key == 'extension' } : value
+
+              (value_without_extensions.present? || value_without_extensions == false) &&
+                (element_definition[:fixed_value].blank? || value == element_definition[:fixed_value])
+
+            end
+
+            # Note that false.present? => false, which is why we need to add this extra check
+            value_found.present? || value_found == false
+          end
+        end
+
+      @missing_elements
+    end
+
+    def must_support_slices
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:slices].reject{ |slice| slice[:uscdi_only] }
+      else
+        metadata.must_supports[:slices]
+      end
+    end
+
+    def missing_slices(resources = [])
+      @missing_slices ||=
+        must_support_slices.select do |slice|
+          resources.none? do |resource|
+            path = slice[:path] # .delete_suffix('[x]')
+            find_slice(resource, path, slice[:discriminator]).present?
+          end
+        end
+    end
+
+    def find_slice(resource, path, discriminator)
+      find_a_value_at(resource, path) do |element|
+        case discriminator[:type]
+        when 'patternCodeableConcept'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternCoding'
+          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternIdentifier'
+          find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
+        when 'value'
+          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+          find_slice_by_values(element, values)
+        when 'type'
+          case discriminator[:code]
+          when 'Date'
+            begin
+              Date.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'DateTime'
+            begin
+              DateTime.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'String'
+            element.is_a? String
+          else
+            element.is_a? FHIR.const_get(discriminator[:code])
+          end
+        when 'requiredBinding'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) {|coding| discriminator[:values].include?(coding.code) }
+        end
+      end
+    end
+
+    def find_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      Array.wrap(element).find do |el|
+        path_prefixes.all? do |path_prefix|
+          value_definitions_for_path =
+            value_definitions
+              .select { |value_definition| value_definition[:path].first == path_prefix }
+              .each { |value_definition| value_definition[:path].shift }
+
+          find_a_value_at(el, path_prefix) do |el_found|
+            child_element_value_definitions, current_element_value_definitions =
+              value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+            current_element_values_match =
+              current_element_value_definitions
+                .all? { |value_definition| value_definition[:value] == el_found }
+
+            child_element_values_match =
+              child_element_value_definitions.present? ?
+                find_slice_by_values(el_found, child_element_value_definitions) : true
+
+            current_element_values_match && child_element_values_match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/provenance_validator.rb

@@ -0,0 +1,37 @@
+module DaVinciPlanNetTestKit
+  class ProvenanceValidator
+    include FHIRResourceNavigation
+
+    def self.validate(...)
+      new(...).validate
+    end
+
+    attr_reader :resource, :validation_messages
+
+    def initialize(resource)
+      @resource = resource
+      @validation_messages = []
+    end
+
+    def validate
+      # Invariant provenance-1 in US Core 5 causes validation error. See FHIR-39518
+      return validation_messages unless resource.instance_of?(FHIR::Provenance)
+
+      failed_provenance =
+        find_a_value_at(resource, 'agent') do |agent|
+          ['Practitioner', 'Device'].any? { |resource_type| agent.who.reference&.include?(resource_type) } &&
+          agent.onBehalfOf.nil?
+        end
+
+
+      if failed_provenance.present?
+        validation_messages << {
+          type: 'error',
+          message: "#{resource.resourceType}/#{resource.id}: Rule provenance-1: 'onBehalfOf SHALL be present when Provenance.agent.who is a Practitioner or Device' Failed"
+        }
+      end
+
+      validation_messages
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/read_test.rb

@@ -0,0 +1,62 @@
+module DaVinciPlanNetTestKit
+  module ReadTest
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def perform_read_test(resources, reply_handler = nil)
+      skip_if resources.blank?, no_resources_skip_message
+
+      resources_to_read = readable_resources(resources)
+
+      assert resources_to_read.present?, "No #{resource_type} id found."
+
+      if config.options[:read_all_resources]
+        resources_to_read.each do |resource|
+          read_and_validate(resource)
+        end
+      else
+        read_and_validate(resources_to_read.first)
+      end
+    end
+
+    def readable_resources(resources)
+      resources
+        .select { |resource| resource.is_a?(resource_class) || resource.is_a?(FHIR::Reference) }
+        .select { |resource| (resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id).present? }
+        .compact
+        .uniq { |resource| resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id }
+    end
+
+    def read_and_validate(resource_to_read)
+      id = resource_id(resource_to_read)
+
+      fhir_read resource_type, id
+
+      assert_response_status(200)
+      assert_resource_type(resource_type)
+      assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
+
+      if resource_to_read.is_a? FHIR::Reference
+        all_scratch_resources << resource
+      end
+    end
+
+    def resource_id(resource)
+      resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+      "Please use #{resource_type}s with more information."
+    end
+
+    def bad_resource_id_message(expected_id)
+      "Expected resource to have id: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
+    end
+
+    def resource_class
+      FHIR.const_get(resource_type)
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/reference_resolution_test.rb

@@ -0,0 +1,179 @@
+require_relative 'fhir_resource_navigation'
+
+module DaVinciPlanNetTestKit
+  module ReferenceResolutionTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
+
+    def perform_reference_resolution_test(resources)
+      skip_if resources.blank?, no_resources_skip_message
+
+      pass if unresolved_references(resources).length.zero?
+
+      skip "Could not resolve Must Support references #{unresolved_references_strings.join(', ')}"
+    end
+
+    def unresolved_references_strings
+      unresolved_reference_hash =
+        unresolved_references.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |missing, hash|
+          hash[missing[:path]] << missing[:target_profile]
+        end
+      unresolved_reference_hash.map { |path, profiles| "#{path}#{"(#{profiles.join('|')})" unless profiles.first.empty?}" }
+    end
+
+    def record_resolved_reference(reference, target_profile)
+      saved_reference = resolved_references.find { |item| item[:reference] == reference.reference }
+
+      if saved_reference.present?
+        if target_profile.present? && !saved_reference[:profiles].include?(target_profile)
+          saved_reference[:profiles] << target_profile
+        end
+      else
+        saved_reference = {
+          reference: reference.reference,
+          profiles: []
+        }
+
+        saved_reference[:profiles] << target_profile if target_profile.present?
+        resolved_references.add(saved_reference)
+      end
+    end
+
+    def is_reference_resolved?(reference, target_profile)
+      resolved_references.any? do |item|
+        item[:reference] == reference.reference &&
+        (
+          target_profile.blank? || item[:profiles].include?(target_profile)
+        )
+      end
+    end
+
+    def resolved_references
+      scratch[:resolved_references] ||= Set.new
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+      'Please use resources with more information.'
+    end
+
+    def must_support_references
+      metadata.must_supports[:elements].select { |element_definition| element_definition[:types]&.include?('Reference') }
+    end
+
+    def must_support_references_with_target_profile
+      # mapping array of target_profiles to array of {path, target_profile} pair
+      must_support_references.map do |element_definition|
+        (element_definition[:target_profiles] || ['']).map do |target_profile|
+          {
+            path: element_definition[:path],
+            target_profile: target_profile
+          }
+        end
+      end.flatten
+    end
+
+    def unresolved_references(resources = [])
+      @unresolved_references ||=
+        must_support_references_with_target_profile.select do |reference_path_profile_pair|
+          path = reference_path_profile_pair[:path]
+          target_profile = reference_path_profile_pair[:target_profile]
+
+          found_one_reference = false
+
+          resolve_one_reference = resources.any? do |resource|
+            value_found = resolve_path(resource, path)
+            next if value_found.empty?
+
+            found_one_reference = true
+
+            value_found.any? do |reference|
+              validate_reference_resolution(resource, reference, target_profile)
+            end
+          end
+
+          found_one_reference && !resolve_one_reference
+        end
+
+      if metadata.must_supports[:choices].present?
+        @unresolved_references.delete_if do |reference|
+          choice_profiles = metadata.must_supports[:choices].find { |choice| choice[:target_profiles]&.include?(reference[:target_profile]) }
+
+          choice_profiles.present? &&
+          choice_profiles[:target_profiles]&.any? { |profile| @unresolved_references.none? { |element| element[:target_profile] == profile } }
+        end
+      end
+
+      @unresolved_references
+    end
+
+    def validate_reference_resolution(resource, reference, target_profile)
+      return true if is_reference_resolved?(reference, target_profile)
+
+      if reference.contained?
+        # if reference_id is blank it is referring to itself, so we know it exists
+        return true if reference.reference_id.blank?
+
+        return resource.contained.any? do |contained_resource|
+            contained_resource&.id == reference.reference_id &&
+              resource_is_valid_with_target_profile?(contained_resource, target_profile)
+          end
+      end
+
+      reference_type = reference.resource_type
+      reference_id = reference.reference_id
+
+      resolved_resource =
+        begin
+          if reference.relative?
+            begin
+              reference.resource_class
+            rescue NameError
+              return false
+            end
+
+            fhir_read(reference_type, reference_id)&.resource
+          else
+            if reference.base_uri.chomp('/') == fhir_client.instance_variable_get(:@base_service_url).chomp('/')
+              fhir_read(reference_type, reference_id)&.resource
+            else
+              get(reference.reference)&.resource
+            end
+          end
+        rescue StandardError => e
+          Inferno::Application['logger'].error("Unable to resolve reference #{reference.reference}")
+          Inferno::Application['logger'].error(e.full_message)
+          return false
+        end
+
+      return false unless resolved_resource&.resourceType == reference_type && resolved_resource&.id == reference_id
+
+      return false unless resource_is_valid_with_target_profile?(resolved_resource, target_profile)
+
+      record_resolved_reference(reference, target_profile)
+      true
+    end
+
+    def resource_is_valid_with_target_profile?(resource, target_profile)
+      return true if target_profile.blank?
+
+      # Only need to know if the resource is valid.
+      # Calling resource_is_valid? causes validation errors to be logged.
+      validator = find_validator(:default)
+
+      target_profile_with_version =  target_profile.include?('|') ? target_profile : "#{target_profile}|#{metadata.profile_version}"
+
+      outcome = FHIR::OperationOutcome.new(JSON.parse(validator.validate(resource, target_profile_with_version)))
+
+      message_hashes = outcome.issue&.map { |issue| validator.message_hash_from_issue(issue, resource) } || []
+
+      message_hashes.concat(validator.additional_validation_messages(resource, target_profile_with_version))
+
+      validator.filter_messages(message_hashes)
+
+      message_hashes.none? { |message_hash| message_hash[:type] == 'error' }
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/request_logger.rb

@@ -0,0 +1,46 @@
+module Inferno
+  module Utils
+    # @private
+    module Middleware
+      class RequestLogger
+        def log_response(response, start_time, end_time, exception = nil)
+          elapsed = end_time - start_time
+          status, _response_headers, body = response if response
+          status, = response if exception
+
+          logger.info("#{status} in #{elapsed.in_milliseconds} ms")
+          return unless body.present?
+
+          body = body.is_a?(Array) ? body.join : body
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+
+        def log_request(env)
+          method = env['REQUEST_METHOD']
+          scheme = env['rack.url_scheme']
+          host = env['HTTP_HOST']
+          path = env['REQUEST_URI']
+          query = env['rack.request.query_string']
+          body = env['rack.input']
+          body = body.instance_of?(Puma::NullIO) ? nil : body.string
+          query_string = query.blank? ? '' : "?#{query}"
+
+          logger.info("#{method} #{scheme}://#{host}#{path}#{query_string}")
+
+          return unless body.present?
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+      end
+    end
+  end
+end