davinci_dtr_test_kit 0.17.1 → 0.18.0

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/questionnaire_package_input_type_test.rb

@@ -0,0 +1,110 @@
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnairePackageInputTypeTest < Inferno::Test
+      id :dtr_v220_payer_questionnaire_package_input_type
+
+      title 'Verify that all $questionnaire-package input types have been provided'
+      description <<~DESCRIPTION
+        This test verifies that the user has supplied inputs which contain each
+        of the available input types for the $questionnaire-package operation:
+        * canonicals specifying the URL and, (optionally) the version of the
+          Questionnaire(s) to retrieve
+        * A CRD/PAS context ID
+        * One or more Request or Encounter resources
+
+        Each input type must be provided in a set of paramaters without the
+        others in order to verify the server's support for each input type.
+      DESCRIPTION
+
+      simulation_verification
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+
+        parameters_list =
+          requests.map do |request|
+            JSON.parse(request.request_body)
+
+            FHIR.from_contents(request.request_body)
+          rescue JSON::ParserError
+            nil
+          end.compact
+
+        skip_if parameters_list.blank?, 'No valid request bodies were provided.'
+
+        assert parameters_list.all?(FHIR::Parameters),
+               'Not all provided request bodies were Parameters resources.'
+
+        unless canonical_input_provided?(parameters_list)
+          add_message(
+            'error',
+            'No $questionnaire-package request body with a Questionnaire canonical was provided.'
+          )
+        end
+
+        unless context_id_input_provided?(parameters_list)
+          add_message(
+            'error',
+            'No $questionnaire-package request body with a CRD/DTR context id was provided.'
+          )
+        end
+
+        unless request_or_encounter_input_provided?(parameters_list)
+          add_message(
+            'error',
+            'No $questionnaire-package request body with an order resource was provided.'
+          )
+        end
+
+        assert_no_error_messages('Not all required $questionnaire-package input types were provided.')
+      end
+
+      def canonical_input_provided?(parameters_list)
+        parameters_list.any? do |parameters|
+          parameters_include_canonical?(parameters) &&
+            !parameters_include_context_id?(parameters) &&
+            !parameters_include_request_or_encounter?(parameters)
+        end
+      end
+
+      def context_id_input_provided?(parameters_list)
+        parameters_list.any? do |parameters|
+          parameters_include_context_id?(parameters) &&
+            !parameters_include_canonical?(parameters) &&
+            !parameters_include_request_or_encounter?(parameters)
+        end
+      end
+
+      def request_or_encounter_input_provided?(parameters_list)
+        parameters_list.any? do |parameters|
+          parameters_include_request_or_encounter?(parameters) &&
+            !parameters_include_canonical?(parameters) &&
+            !parameters_include_context_id?(parameters)
+        end
+      end
+
+      def parameters_include_canonical?(parameters)
+        parameters
+          .parameter
+          .select { |parameter| parameter.name == 'questionnaire' }
+          .any? { |parameter| parameter.valueCanonical.present? }
+      end
+
+      def parameters_include_context_id?(parameters)
+        parameters
+          .parameter
+          .select { |parameter| parameter.name == 'context' }
+          .any? { |parameter| parameter.valueString.present? }
+      end
+
+      def parameters_include_request_or_encounter?(parameters)
+        parameters
+          .parameter
+          .select { |parameter| parameter.name == 'order' }
+          .any? { |parameter| parameter.resource.present? }
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/questionnaire_references_version_specific_test.rb

@@ -0,0 +1,79 @@
+require_relative '../questionnaire_response_reference_validation'
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+require_relative '../../../tags'
+require_relative '../questionnaire_operation_validation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireReferencesVersionTest < Inferno::Test
+      include QuestionnaireResponseReferenceValidation
+      include MultiRequestMessageHelper
+      include QuestionnaireOperationValidation
+
+      id :dtr_v220_payer_questionnaire_references_version_specific
+      title 'Validate version-specific references'
+      description %(
+        This test validates that references to Questionnaires, Libraries, and ValueSets within a Bundle
+        is version specific.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@oper-16'
+
+      TARGET_REFERENCE = ['Questionnaire', 'Library', 'ValueSet'].freeze
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+
+        skip_if requests.blank?, 'No $questionnaire-package requests were made'
+
+        successful_requests = requests.each_with_index.filter_map do |request, request_index|
+          [request, request_index] if [200, 201].include?(request.status)
+        end
+
+        skip_if successful_requests.blank?, 'No successful $questionnaire-package requests were made'
+
+        successful_requests.each do |request, request_index|
+          begin
+            JSON.parse(request.response_body)
+          rescue JSON::ParserError
+            next
+          end
+
+          resource = FHIR.from_contents(request.response_body)
+          next if resource.nil?
+
+          extract_questionnaire_bundles(resource).each_with_index do |bundle, bundle_index|
+            bundle.each_element do |element, _meta, _path|
+              next unless element.is_a?(FHIR::Reference)
+
+              reference = element.reference
+              next if reference.blank?
+
+              resource_type = element.resource_type
+              next unless TARGET_REFERENCE.include?(resource_type)
+
+              next if check_version_reference?(reference)
+
+              add_request_message(
+                'error',
+                "Bundle #{bundle_index}: Unversioned #{resource_type} reference: `#{reference}`",
+                request_index
+              )
+            end
+          end
+        end
+
+        message = "#{requests_with_errors_prefix}References to Questionnaires, Libraries, and ValueSets " \
+                  'within questionnaire package Bundles must be version-specific. '
+
+        assert_no_error_messages("#{message}See Messages for details.")
+      end
+
+      def check_version_reference?(reference)
+        _url, separator, version = reference.to_s.partition('|')
+
+        separator.present? && version.present?
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/questionnaire_response_questionnaire_canonical_test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+require_relative '../../../tags'
+require_relative '../questionnaire_operation_validation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireResponseQuestionnaireCanonicalTest < Inferno::Test
+      include MultiRequestMessageHelper
+      include QuestionnaireOperationValidation
+
+      ADAPTIVE_QUESTIONNAIRE_EXTENSION_URL = 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-questionnaireAdaptive'
+
+      id :dtr_v220_payer_questionnaire_response_questionnaire_canonical
+      title 'Standard QuestionnaireResponse references the package Questionnaire canonical'
+      description %(
+        This test verifies that each QuestionnaireResponse accompanying a standard
+        Questionnaire in a `$questionnaire-package` package Bundle references the
+        canonical of the Questionnaire returned in that same package Bundle.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-122'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        standard_questionnaire_responses_found = false
+
+        requests.each_with_index do |request, request_index|
+          package_bundles_from_request(request).each do |package_bundle|
+            questionnaire = package_resources(package_bundle, FHIR::Questionnaire).first
+            next if adaptive_questionnaire?(questionnaire)
+
+            questionnaire_response = package_resources(package_bundle, FHIR::QuestionnaireResponse).first
+            next unless questionnaire_response
+
+            standard_questionnaire_responses_found = true
+            questionnaire_canonical = canonical(questionnaire)
+            next if questionnaire_response.questionnaire == questionnaire_canonical
+
+            add_request_message(
+              'error',
+              "QuestionnaireResponse.questionnaire `#{questionnaire_response.questionnaire}` does not " \
+              "match a Questionnaire canonical in its package Bundle (#{questionnaire_canonical}).",
+              request_index
+            )
+          end
+        end
+
+        omit_if !standard_questionnaire_responses_found,
+                'No QuestionnaireResponse resources accompanying standard Questionnaires were returned.'
+
+        message = "#{requests_with_errors_prefix}" \
+                  'QuestionnaireResponse.questionnaire must match a Questionnaire canonical in its package Bundle.'
+        assert_no_error_messages("#{message} See Messages for details.")
+      end
+
+      private
+
+      def package_bundles_from_request(request)
+        resource = FHIR.from_contents(request.response_body)
+        return [] unless resource.is_a?(FHIR::Parameters)
+
+        extract_questionnaire_bundles(resource)
+      rescue JSON::ParserError, FHIR::ClientException
+        []
+      end
+
+      def package_resources(package_bundle, resource_class)
+        package_bundle.entry.filter_map do |entry|
+          entry.resource if entry.resource.is_a?(resource_class)
+        end
+      end
+
+      def adaptive_questionnaire?(questionnaire)
+        questionnaire.is_a?(FHIR::Questionnaire) &&
+          questionnaire.extension.any? do |extension|
+            extension.url == ADAPTIVE_QUESTIONNAIRE_EXTENSION_URL &&
+              (extension.valueBoolean || extension.valueUrl.present?)
+          end
+      end
+
+      def canonical(questionnaire)
+        return if questionnaire.blank? || questionnaire.url.blank?
+
+        "#{questionnaire.url}#{"|#{questionnaire.version}" if questionnaire.version.present?}"
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/questionnaire_response_references_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../questionnaire_response_reference_validation'
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireResponseReferencesTest < Inferno::Test
+      include QuestionnaireResponseReferenceValidation
+      include MultiRequestMessageHelper
+
+      id :dtr_v220_payer_questionnaire_response_references
+      title 'QuestionnaireResponse references target contained or client FHIR resources'
+      description %(
+        This test verifies that every reference in each QuestionnaireResponse returned by
+        `$questionnaire-package` points to either a resource contained in that
+        QuestionnaireResponse or a resource on the DTR client's FHIR endpoint.
+        Relative references are interpreted relative to the DTR client's FHIR endpoint.
+        To validate absolute references, provide the DTR Client FHIR Endpoint input.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-139'
+
+      input :client_fhir_endpoint, optional: true
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        responses_by_request = requests.map { |request| questionnaire_responses_from_request(request) }
+        skip_if responses_by_request.all?(&:empty?), 'No QuestionnaireResponse resources were returned.'
+        absolute_references_returned = responses_by_request.flatten.any? do |response|
+          questionnaire_response_has_absolute_reference?(response)
+        end
+
+        responses_by_request.each_with_index do |questionnaire_responses, request_index|
+          questionnaire_responses.each do |questionnaire_response|
+            invalid_questionnaire_response_references(questionnaire_response, client_fhir_endpoint).each do |reference|
+              add_request_message('error', reference, request_index)
+            end
+          end
+        end
+
+        message = "#{requests_with_errors_prefix}" \
+                  "References must target contained resources or the DTR client's FHIR endpoint. "
+        assert_no_error_messages("#{message}See Messages for details.")
+
+        skip_if client_fhir_endpoint.blank? && absolute_references_returned,
+                'Absolute QuestionnaireResponse references were returned, but no DTR Client FHIR Endpoint was provided.'
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/questionnaire_response_validation_test.rb

@@ -0,0 +1,63 @@
+require_relative '../../../tags'
+require_relative '../../../urls'
+require_relative '../../validation_test'
+require_relative '../questionnaire_operation_validation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireResponseValidationTest < Inferno::Test
+      include URLs
+      include DaVinciDTRTestKit::ValidationTest
+      include QuestionnaireOperationValidation
+
+      id :dtr_v220_payer_questionnaire_response_validation
+
+      title 'Verify that the response conforms to the DTR Questionnaire Package Output Parameters profile'
+      description %(
+        Inferno will verify that the payer server's response to the
+        questionnaire-package operation conforms to the [Questionnaire Package
+        Output Parameters
+        profile](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-qpackage-output-parameters.html).
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@oper-10'
+      input :url
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+
+        skip_if requests.blank?, 'No $questionnaire-package requests were made'
+
+        requests.each_with_index do |request, index|
+          unless [200, 201].include? request.response[:status]
+            add_message(
+              'error',
+              "Request #{index + 1} was unsuccessful."
+            )
+          end
+
+          JSON.parse(request.response_body)
+
+          resource = FHIR.from_contents(request.response_body)
+
+          if resource.nil?
+            add_message(
+              'error',
+              "Response #{index + 1} did not contain FHIR resources."
+            )
+
+            next
+          end
+
+          perform_questionnaire_package_response_validation(resource, index)
+        rescue JSON::ParserError
+          add_message(
+            'error',
+            "Response #{index + 1} contained invalid JSON."
+          )
+        end
+
+        assert_no_error_messages('Not all responses were valid. See messages for details.')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/source_data_error_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class SourceDataErrorTest < Inferno::Test
+      id :dtr_v220_payer_source_data_error
+      title 'Source data errors return a 4xx response with an OperationOutcome'
+      description %(
+        Inferno invokes `Questionnaire/$questionnaire-package` using a
+        tester-provided request containing source data that the DTR server cannot
+        resolve, such as an unknown coverage or context identifier. Inferno verifies
+        that the server returns a 4xx response with an OperationOutcome.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-130'
+
+      input :source_data_error_request,
+            title: '$questionnaire-package Request with Invalid Source Data',
+            description: %(
+              Provide a `Parameters` resource in JSON format containing source data
+              known to be unresolvable by the DTR server, such as an unknown coverage
+              or context identifier.
+            ),
+            type: 'textarea'
+
+      run do
+        assert_valid_json source_data_error_request, 'The provided $questionnaire-package request is not valid JSON.'
+        parameters = FHIR.from_contents(source_data_error_request)
+        assert_resource_type(:parameters, resource: parameters)
+
+        fhir_operation(
+          '/Questionnaire/$questionnaire-package',
+          body: parameters,
+          headers: { 'Content-Type': 'application/fhir+json' }
+        )
+
+        status = request.status.to_i
+        assert status.between?(400, 499),
+               "Expected a 4xx response for invalid source data, but received HTTP #{status}."
+        assert_resource_type(:operation_outcome)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_package_support/value_set_validation_test.rb

@@ -0,0 +1,90 @@
+require_relative '../../../tags'
+require_relative '../../validation_test'
+require_relative '../questionnaire_operation_validation'
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class ValueSetValidationTest < Inferno::Test
+      include DaVinciDTRTestKit::ValidationTest
+      include QuestionnaireOperationValidation
+      include MultiRequestMessageHelper
+
+      id :dtr_v220_payer_value_set_validation
+      title 'Validate questionnaire-package response Bundle includes all external ValueSet instances'
+      description %(
+        This test validates the response to the $questionnaire-package includes all external ValueSet
+        instances referenced by the Questionnaire.
+
+        It verifies that the Bundle includes all ValueSet instances referenced by the Questionnaire.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@oper-14'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+
+        skip_if requests.blank?, 'No $questionnaire-package requests were made'
+
+        successful_requests = requests.each_with_index.select do |request, _request_index|
+          [200, 201].include? request.status
+        end
+
+        skip_if successful_requests.blank?, 'No successful $questionnaire-package requests were made'
+
+        external_value_set_referenced = false
+
+        successful_requests.each do |request, request_index|
+          resource = FHIR.from_contents(request.response_body)
+
+          extract_questionnaire_bundles(resource).each do |bundle|
+            bundle_value_set_urls = bundle.entry.filter_map do |entry|
+              next unless entry&.resource.is_a?(FHIR::ValueSet)
+
+              "#{entry.resource.url}|#{entry.resource.version}"
+            end
+
+            external_value_set_urls = extract_questionnaires_from_bundles([bundle]).flat_map do |questionnaire|
+              value_set_urls_from_items(questionnaire.item)
+            end
+
+            next if external_value_set_urls.empty?
+
+            external_value_set_referenced = true
+
+            missing_value_set_urls = external_value_set_urls.uniq - bundle_value_set_urls.uniq
+
+            next if missing_value_set_urls.empty?
+
+            add_request_message(
+              'error',
+              "Bundle is missing ValueSet instances: #{missing_value_set_urls.join(', ')}",
+              request_index
+            )
+          end
+        end
+
+        omit_if !external_value_set_referenced, 'No external ValueSet referenced'
+
+        assert_no_error_messages(
+          "#{requests_with_errors_prefix}Questionnaire-package response Bundles are missing ValueSet instances."
+        )
+      end
+
+      def value_set_urls_from_items(items)
+        items.flat_map do |item|
+          urls = []
+          add_value_set_url(urls, item.answerValueSet)
+          urls + value_set_urls_from_items(item.item)
+        end
+      end
+
+      def add_value_set_url(urls, reference)
+        reference = reference.to_s
+        return if reference.blank? || reference.start_with?('#')
+
+        urls << reference
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_response_reference_validation.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    module QuestionnaireResponseReferenceValidation
+      def questionnaire_responses_from_request(request)
+        resource = FHIR.from_contents(request.response_body)
+        questionnaire_responses_from_resource(resource)
+      rescue JSON::ParserError, FHIR::ClientException
+        []
+      end
+
+      def questionnaire_responses_from_resource(resource)
+        case resource&.resourceType
+        when 'QuestionnaireResponse'
+          [resource]
+        when 'Bundle'
+          resource.entry.filter_map do |entry|
+            questionnaire_responses_from_resource(entry.resource)
+          end.flatten
+        when 'Parameters'
+          resource.parameter.filter_map do |parameter|
+            questionnaire_responses_from_resource(parameter.resource)
+          end.flatten
+        else
+          []
+        end
+      end
+
+      def invalid_questionnaire_response_references(questionnaire_response, client_fhir_endpoint)
+        contained_ids = questionnaire_response.contained.filter_map(&:id)
+        invalid_references = []
+
+        questionnaire_response_references(questionnaire_response).each do |reference|
+          reference_value = reference[:value]
+          location = reference[:location]
+          if reference_value.start_with?('#')
+            invalid_references << "#{location} references `#{reference_value}`" \
+              unless contained_ids.include?(reference_value.delete_prefix('#'))
+          elsif invalid_absolute_reference?(reference_value, client_fhir_endpoint)
+            invalid_references << "#{location} references `#{reference_value}`"
+          end
+        end
+
+        invalid_references
+      end
+
+      def invalid_contained_reference_locations(questionnaire_response)
+        permitted_locations = answer_value_reference_locations(questionnaire_response.item)
+        invalid_references = []
+
+        questionnaire_response_references(questionnaire_response).each do |reference|
+          reference_value = reference[:value]
+          location = reference[:location]
+          next unless reference_value.start_with?('#') && !permitted_locations.include?(location)
+
+          invalid_references << "#{location} references `#{reference_value}`"
+        end
+
+        invalid_references
+      end
+
+      # Returns all populated FHIR Reference values below a FHIR resource.
+      #
+      # Given a QuestionnaireResponse with the following JSON representation:
+      # { "subject": { "reference": "Patient/123" },
+      #   "item": [{ "answer": [{ "valueReference": { "reference": "#observation" } }] }] }
+      #
+      # it returns:
+      # [{ value: 'Patient/123', location: 'subject.reference' },
+      #  { value: '#observation', location: 'item[0].answer[0].valueReference.reference' }]
+      def questionnaire_response_references(questionnaire_response)
+        references = []
+
+        questionnaire_response.each_element do |element, _metadata, path|
+          next unless element.is_a?(FHIR::Reference) && element.reference.present?
+
+          references << { value: element.reference, location: "#{path}.reference" }
+        end
+
+        references
+      end
+
+      # Returns the locations of QuestionnaireResponse answer value references.
+      #
+      # Given QuestionnaireResponse items with the following JSON representation:
+      # [{ "answer": [{ "valueReference": { "reference": "#observation" } }] }]
+      #
+      # it returns:
+      # ['item[0].answer[0].valueReference.reference']
+      def answer_value_reference_locations(items, item_location = 'item', locations = [])
+        items.each_with_index do |item, item_index|
+          location = "#{item_location}[#{item_index}]"
+          answer_value_reference_locations(item.item, "#{location}.item", locations)
+
+          item.answer.each_with_index do |answer, answer_index|
+            answer_location = "#{location}.answer[#{answer_index}]"
+            locations << "#{answer_location}.valueReference.reference" if answer.valueReference&.reference.present?
+            answer_value_reference_locations(answer.item, "#{answer_location}.item", locations)
+          end
+        end
+
+        locations
+      end
+
+      def absolute_reference?(reference)
+        URI.parse(reference).absolute?
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def questionnaire_response_has_absolute_reference?(questionnaire_response)
+        questionnaire_response_references(questionnaire_response).any? do |reference|
+          absolute_reference?(reference[:value])
+        end
+      end
+
+      def invalid_absolute_reference?(reference, client_fhir_endpoint)
+        client_fhir_endpoint.present? && absolute_reference?(reference) &&
+          !reference_on_client_endpoint?(reference, client_fhir_endpoint)
+      end
+
+      def reference_on_client_endpoint?(reference, client_fhir_endpoint)
+        return false if client_fhir_endpoint.blank?
+
+        normalized_endpoint = client_fhir_endpoint.delete_suffix('/')
+        reference == normalized_endpoint || reference.start_with?("#{normalized_endpoint}/")
+      end
+    end
+  end
+end