davinci_dtr_test_kit 0.17.0 → 0.18.0

data/lib/davinci_dtr_test_kit/server/v2.2.0/next_question_support/next_contained_questionnaire_response_references_test.rb

@@ -0,0 +1,46 @@
+# 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 NextQuestionContainedResponseReferencesTest < Inferno::Test
+      include QuestionnaireResponseReferenceValidation
+      include MultiRequestMessageHelper
+
+      id :dtr_v220_payer_next_question_contained_response_references
+      title 'Contained $next-question QuestionnaireResponse references occur only in answer values'
+      description %(
+        This test verifies that a QuestionnaireResponse returned by `$next-question` uses
+        contained resource references only as
+        `QuestionnaireResponse.item.answer.valueReference` values.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-140',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@spec-141'
+
+      run do
+        load_tagged_requests(NEXT_TAG)
+
+        omit_if requests.blank?, 'No $next-question requests were made.'
+
+        responses_by_request = requests.map { |request| questionnaire_responses_from_request(request) }
+
+        skip_if responses_by_request.all?(&:empty?), 'No QuestionnaireResponse resources were returned.'
+
+        responses_by_request.each_with_index do |questionnaire_responses, request_index|
+          questionnaire_responses.each do |questionnaire_response|
+            invalid_contained_reference_locations(questionnaire_response).each do |reference|
+              add_request_message('error', reference, request_index)
+            end
+          end
+        end
+
+        message = "#{requests_with_errors_prefix}" \
+                  'Contained resource references are permitted only in item.answer valueReference '
+        assert_no_error_messages("#{message}elements. See Messages for details.")
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/next_question_support/next_question_response_references_test.rb

@@ -0,0 +1,56 @@
+# 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 NextQuestionResponseReferencesTest < Inferno::Test
+      include QuestionnaireResponseReferenceValidation
+      include MultiRequestMessageHelper
+
+      id :dtr_v220_payer_next_question_response_references
+      title '$next-question QuestionnaireResponse references only target contained or client FHIR resources'
+      description %(
+        This test verifies that every reference in each QuestionnaireResponse returned by
+        `$next-question` 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(NEXT_TAG)
+
+        omit_if requests.blank?, 'No $next-question requests were made.'
+
+        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/next_question_support/next_question_response_validation_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class NextQuestionResponseValidationTest < Inferno::Test
+      NEXT_QUESTION_OUTPUT_PARAMETERS_PROFILE =
+        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-next-question-output-parameters|2.2.0'
+      ADAPTIVE_QUESTIONNAIRE_RESPONSE_PROFILE =
+        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse-adapt|2.2.0'
+
+      id :dtr_v220_payer_next_question_response_validation
+      title 'Verify that the $next-question response conforms to the DTR Next Question Output Parameters profile'
+      description %(
+        Inferno verifies that each payer server response to the `$next-question`
+        operation conforms to the [DTR Next Question Output Parameters profile](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-next-question-output-parameters.html)
+        when it is a Parameters resource, or to the [DTR Questionnaire Response
+        for adaptive form profile](https://hl7.org/fhir/us/davinci-dtr/2.2.0/en/StructureDefinition-dtr-questionnaireresponse-adapt.html)
+        when it is a plain QuestionnaireResponse resource.
+      )
+
+      run do
+        load_tagged_requests(NEXT_TAG)
+
+        omit_if requests.blank?, 'No $next-question requests were made.'
+
+        requests.each_with_index do |request, index|
+          add_message('error', "Request #{index + 1} was unsuccessful.") unless [200, 201].include? request.status
+
+          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_next_question_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
+
+      def perform_next_question_response_validation(resource, index)
+        case resource
+        when FHIR::Parameters
+          resource_is_valid?(
+            resource:,
+            profile_url: NEXT_QUESTION_OUTPUT_PARAMETERS_PROFILE,
+            message_prefix: "Response #{index + 1}: "
+          )
+        when FHIR::QuestionnaireResponse
+          resource_is_valid?(
+            resource:,
+            profile_url: ADAPTIVE_QUESTIONNAIRE_RESPONSE_PROFILE,
+            message_prefix: "Response #{index + 1}: "
+          )
+        else
+          add_message('error', "Response #{index + 1} was not a Parameters or QuestionnaireResponse resource.")
+        end
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/contained_binary_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../../tags'
+require_relative '../questionnaire_response_reference_validation'
+require_relative 'contained_binary_validation'
+require_relative '../../../cross_suite/v2.2.0/multi_request_message_helper'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class ContainedBinaryTest < Inferno::Test
+      include ContainedBinaryValidation
+      include MultiRequestMessageHelper
+      include QuestionnaireResponseReferenceValidation
+
+      id :dtr_v220_payer_contained_binary
+      title 'Contained Binary resources are PDFs or safe XHTML'
+      description %(
+        This test verifies that Binary resources contained in QuestionnaireResponses
+        returned from the `$questionnaire-package` or `$next-question` operations are
+        either PDFs or XHTML fragments that follow the FHIR R4 Narrative safety rules.
+        XHTML must be a non-empty `<div>` fragment in the XHTML namespace and must not
+        contain active content, scripts, external stylesheets, deprecated elements, or
+        event-related attributes.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-160'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+        load_tagged_requests(NEXT_TAG)
+        omit_if requests.blank?,
+                'No $questionnaire-package or $next-question requests were made'
+
+        binary_found = false
+        requests.each_with_index do |request, request_index|
+          questionnaire_responses_from_request(request).each do |questionnaire_response|
+            contained_binaries([questionnaire_response]).each do |binary|
+              binary_found = true
+              next if contained_binary_is_safe?(binary)
+
+              add_request_message(
+                'error',
+                "#{binary_description(binary)} is not a PDF or safe XHTML fragment.",
+                request_index
+              )
+            end
+          end
+        end
+
+        omit_if !binary_found, 'No Binary resources were contained in QuestionnaireResponses'
+        message = "#{requests_with_errors_prefix}" \
+                  'Contained Binary resources must be PDFs or safe XHTML fragments. See Messages for details.'
+        assert_no_error_messages(message)
+      end
+
+      def binary_description(binary)
+        binary.id.present? ? "Binary `#{binary.id}`" : 'contained Binary without an id'
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/contained_binary_validation.rb

@@ -0,0 +1,128 @@
+require 'base64'
+require 'nokogiri'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    module ContainedBinaryValidation
+      PDF_CONTENT_TYPE = 'application/pdf'.freeze
+      XHTML_CONTENT_TYPE = 'application/xhtml+xml'.freeze
+      XHTML_NAMESPACE = 'http://www.w3.org/1999/xhtml'.freeze
+
+      # TODO: Review the FHIR-referenced HTML 4.0 chapters in detail and determine
+      # whether this validator needs additional allowed-element or allowed-attribute handling.
+      #
+      # This validator interprets Binary XHTML according to the FHIR R4 Narrative
+      # fragment rules. It enforces the explicitly prohibited elements and
+      # attributes, but does not yet attempt a comprehensive HTML allowlist.
+      # https://hl7.org/fhir/R4/narrative.html#security
+      #
+      # "The XHTML content SHALL NOT contain a head, a body element,
+      # external stylesheet references, deprecated elements, scripts,
+      # forms, base/link/xlink, frames, iframes, objects or
+      # event related attributes (e.g. onClick)."
+      PROHIBITED_ELEMENTS = %w[
+        base body form frame frameset head iframe input link object script style
+      ].freeze
+      # HTML 4.0 deprecated elements: https://www.w3.org/TR/REC-html40-971218/appendix/changes.html#h-A.1.2
+      DEPRECATED_ELEMENTS = %w[applet basefont center dir font isindex menu s strike u].freeze
+      EXECUTABLE_URL_SCHEMES = %w[javascript vbscript].freeze
+
+      def contained_binaries(questionnaire_responses)
+        questionnaire_responses.flat_map do |questionnaire_response|
+          questionnaire_response.contained&.grep(FHIR::Binary) || []
+        end
+      end
+
+      def contained_binary_is_safe?(binary)
+        return true if binary.contentType == PDF_CONTENT_TYPE
+        return false unless binary.contentType == XHTML_CONTENT_TYPE
+
+        safe_xhtml?(Base64.strict_decode64(binary.data.to_s))
+      rescue ArgumentError
+        false
+      end
+
+      def safe_xhtml?(xhtml)
+        document = parse_xhtml(xhtml)
+
+        narrative_fragment?(document) &&
+          document.errors.empty? &&
+          narrative_has_content?(document) &&
+          document_has_no_unsafe_content?(document)
+      rescue Nokogiri::XML::SyntaxError
+        false
+      end
+
+      private
+
+      def parse_xhtml(xhtml)
+        # Strict parsing rejects malformed XHTML. `nonet` prevents XML from
+        # loading any network resources while it is being parsed.
+        Nokogiri::XML::Document.parse(xhtml) { |config| config.strict.nonet }
+      end
+
+      def document_has_no_unsafe_content?(document)
+        # Inspect every nested XHTML element, including elements in the default
+        # XHTML namespace which a non-namespaced XPath would not reliably select.
+        document.root.traverse do |node|
+          return false if node.element? && unsafe_xhtml_element?(node)
+        end
+
+        true
+      end
+
+      def narrative_fragment?(document)
+        # FHIR Narrative XHTML is represented as a div fragment in the XHTML namespace,
+        # rather than as a complete HTML document.
+        document.root&.name == 'div' && document.root.namespace&.href == XHTML_NAMESPACE
+      end
+
+      def narrative_has_content?(document)
+        # FHIR Narrative requires non-whitespace text or an image in the div fragment.
+        !document.root.text.strip.empty? ||
+          !document.root.at_xpath('.//xhtml:img', xhtml: XHTML_NAMESPACE).nil?
+      end
+
+      def unsafe_xhtml_element?(element)
+        prohibited_element?(element) ||
+          deprecated_element?(element) ||
+          xlink_node?(element) ||
+          element.attribute_nodes.any? { |attribute| unsafe_xhtml_attribute?(attribute) }
+      end
+
+      def prohibited_element?(element)
+        PROHIBITED_ELEMENTS.include?(element.name.downcase)
+      end
+
+      def deprecated_element?(element)
+        DEPRECATED_ELEMENTS.include?(element.name.downcase)
+      end
+
+      def xlink_node?(node)
+        # xlink is an XML namespace, so it can qualify either an element or an
+        # attribute (for example, xlink:href) rather than appearing as an HTML element.
+        node.namespace&.prefix == 'xlink'
+      end
+
+      def unsafe_xhtml_attribute?(attribute)
+        # In XHTML, event handlers are attributes beginning with `on`, such as
+        # `onclick`. They run JavaScript when the corresponding browser event occurs.
+        return true if attribute.name.match?(/\Aon/i)
+
+        return true if xlink_node?(attribute)
+
+        # `href` and `src` are the XHTML attributes that direct a browser to
+        # navigate to or load a URL. Other attributes cannot invoke a URL scheme.
+        return false unless %w[href src].include?(attribute.name.downcase)
+
+        # `javascript:` and `vbscript:` URLs execute code when followed instead
+        # of loading a document or image.
+        EXECUTABLE_URL_SCHEMES.include?(url_scheme(attribute.value))
+      end
+
+      def url_scheme(url)
+        url.to_s.strip.partition(':').first.downcase
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/cql_library_validation_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../../tags'
+require_relative '../questionnaire_operation_validation'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class CQLLibraryValidationTest < Inferno::Test
+      include QuestionnaireOperationValidation
+
+      id :dtr_v220_payer_cql_library_validation
+
+      title 'All referenced CQL Libraries are included'
+      description %(
+        Inferno will verify that the payer server's response to the
+        questionnaire-package operation includes all CQL Libraries referenced in
+        the returned Questionnaires.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-87',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@spec-95',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@spec-98',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@spec-99',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@oper-13',
+                            'hl7.fhir.us.davinci-dtr_2.2.0@oper-16'
+
+      run do
+        load_tagged_requests(QUESTIONNAIRE_TAG)
+
+        successful_requests = requests.select { |request| [200, 201].include? request.response[:status] }
+
+        skip_if successful_requests.blank?, 'No successful $questionnaire-package requests were made'
+
+        library_count = 0
+
+        successful_requests.each_with_index do |request, index|
+          JSON.parse(request.response_body)
+
+          resource = FHIR.from_contents(request.response_body)
+
+          next if resource.nil?
+
+          questionnaire_bundles = extract_questionnaire_bundles(resource)
+          libraries = extract_libraries_from_bundles(questionnaire_bundles)
+
+          next if libraries.blank?
+
+          check_libraries(resource, index)
+
+          library_count += libraries.length
+        rescue JSON::ParserError
+          next
+        end
+
+        assert_no_error_messages('Not all responses contained all necessary valid CQL Libraries.')
+
+        omit_if library_count.zero?, 'No CQL libraries were found.'
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/questionnaire_design_support.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../../../tags'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    module QuestionnaireDesignSupport
+      CQL_MEDIA_TYPES = [
+        'text/cql',
+        'text/cql-expression',
+        'text/cql-identifier'
+      ].freeze
+
+      private
+
+      # Returns a Hash for each Questionnaire returned in a tagged response:
+      # { questionnaire:, operation:, request_index: }
+      # request_index is scoped independently to each operation.
+      def returned_questionnaires
+        questionnaires_from_requests(load_tagged_requests(QUESTIONNAIRE_TAG), '$questionnaire-package') +
+          questionnaires_from_requests(load_tagged_requests(NEXT_TAG), '$next-question')
+      end
+
+      def questionnaires_from_requests(requests, operation)
+        requests.each_with_index.flat_map do |request, request_index|
+          next [] if request.response_body.blank?
+
+          resource = FHIR.from_contents(request.response_body)
+          questionnaires_from_resource(resource).map do |questionnaire|
+            { questionnaire:, operation:, request_index: }
+          end
+        rescue JSON::ParserError, FHIR::ClientException
+          []
+        end
+      end
+
+      def questionnaires_from_resource(resource)
+        case resource.resourceType
+        when 'Questionnaire'
+          [resource]
+        when 'QuestionnaireResponse'
+          resource.contained.grep(FHIR::Questionnaire)
+        when 'Bundle'
+          questionnaires_from_resources(resource.entry.map(&:resource))
+        when 'Parameters'
+          questionnaires_from_resources(resource.parameter.map(&:resource))
+        else
+          []
+        end
+      end
+
+      def questionnaires_from_resources(resources)
+        resources.compact.flat_map { |resource| questionnaires_from_resource(resource) }
+      end
+
+      def questionnaire_items(questionnaire)
+        questionnaire.item.flat_map { |item| [item] + questionnaire_items(item) }
+      end
+
+      def cql_expression?(expression)
+        CQL_MEDIA_TYPES.include?(expression.language.to_s.split(';').first.strip)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/questionnaire_expression_elm_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'questionnaire_design_support'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireExpressionElmTest < Inferno::Test
+      include QuestionnaireDesignSupport
+
+      ALTERNATIVE_EXPRESSION_URL = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/alternativeExpression'
+
+      id :dtr_v220_payer_questionnaire_expression_elm
+      title 'Questionnaire expressions include compiled JSON ELM'
+      description %(
+        Inferno verifies that each Expression in the returned Questionnaires has
+        an Alternative Expression extension containing compiled JSON ELM.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-96'
+
+      run do
+        questionnaire_details = returned_questionnaires
+        skip_if questionnaire_details.blank?, 'No Questionnaire resources were returned'
+
+        cql_expressions = questionnaire_details.flat_map { |details| cql_questionnaire_expressions(details) }
+        omit_if cql_expressions.blank?, 'No CQL expressions were found'
+
+        expressions_without_elm = cql_expressions.reject do |details|
+          alternative_expression_present?(details[:expression])
+        end
+
+        expressions_without_elm.each do |details|
+          add_message(
+            'error',
+            "#{details[:location]} does not include an Alternative Expression extension with compiled JSON ELM."
+          )
+        end
+
+        assert expressions_without_elm.blank?,
+               'One or more CQL expressions did not include compiled JSON ELM. See messages for details.'
+      end
+
+      private
+
+      def cql_questionnaire_expressions(details)
+        questionnaire = details[:questionnaire]
+        cql_expressions_from_extensions(questionnaire.extension, details, 'Questionnaire-level extension') +
+          questionnaire_items(questionnaire).flat_map do |item|
+            cql_expressions_from_extensions(item.extension, details, "linkId `#{item.linkId}`")
+          end
+      end
+
+      def cql_expressions_from_extensions(extensions, details, location)
+        extensions.flat_map do |extension|
+          expressions = []
+          if extension.valueExpression.present? && cql_expression?(extension.valueExpression)
+            expressions << {
+              expression: extension.valueExpression,
+              location: "#{request_location(details)}, #{location}"
+            }
+          end
+          expressions.concat(cql_expressions_from_extensions(extension.extension, details, location))
+        end
+      end
+
+      def request_location(details)
+        "#{details[:operation]} request #{details[:request_index] + 1}"
+      end
+
+      def alternative_expression_present?(expression)
+        expression.extension.any? do |extension|
+          extension.url == ALTERNATIVE_EXPRESSION_URL && expression_contains_elm?(extension.valueExpression)
+        end
+      end
+
+      def expression_contains_elm?(expression)
+        expression&.language == 'application/elm+json' &&
+          (expression&.expression.present? || extension.valueExpression&.reference.present?)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/questionnaire_expression_language_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'questionnaire_design_support'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnaireExpressionLanguageTest < Inferno::Test
+      include QuestionnaireDesignSupport
+
+      id :dtr_v220_payer_questionnaire_expression_language
+      title 'Questionnaire flow and rendering expressions use CQL'
+      description %(
+        Inferno verifies that Expression-valued Questionnaire item extensions are
+        written in CQL. This requirement is conditional and is omitted when no
+        such expressions are present.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-18'
+
+      run do
+        questionnaire_details = returned_questionnaires
+        skip_if questionnaire_details.blank?, 'No Questionnaire resources were returned'
+
+        expressions = questionnaire_details.flat_map { |details| questionnaire_item_expressions(details) }
+        omit_if expressions.blank?, 'No flow or rendering expressions were found'
+
+        non_cql_expressions = expressions.reject do |details|
+          cql_expression?(details[:expression])
+        end
+        non_cql_details = non_cql_expressions.map do |details|
+          language = details[:expression].language.presence || 'missing'
+          "#{request_location(details[:request_details])} linkId `#{details[:link_id]}` (language `#{language}`)"
+        end
+
+        assert non_cql_expressions.blank?,
+               "The following flow or rendering expressions were not written in CQL: #{non_cql_details.join(', ')}"
+      end
+
+      private
+
+      def questionnaire_item_expressions(details)
+        questionnaire = details[:questionnaire]
+        questionnaire_items(questionnaire).flat_map do |item|
+          item.extension.flat_map do |extension|
+            expressions_from_extension(extension).map do |expression|
+              { expression:, link_id: item.linkId, request_details: details }
+            end
+          end
+        end
+      end
+
+      def expressions_from_extension(extension)
+        [
+          extension.valueExpression,
+          *extension.extension.flat_map { |nested_extension| expressions_from_extension(nested_extension) }
+        ].compact
+      end
+
+      def request_location(details)
+        "#{details[:operation]} request #{details[:request_index] + 1}"
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/server/v2.2.0/questionnaire_design/questionnaire_prepopulation_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'questionnaire_design_support'
+
+module DaVinciDTRTestKit
+  module DTRPayerServerV220
+    class QuestionnairePrepopulationTest < Inferno::Test
+      include QuestionnaireDesignSupport
+
+      POPULATION_EXPRESSION_URLS = [
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-initialExpression',
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-candidateExpression',
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-contextExpression'
+      ].freeze
+
+      id :dtr_v220_payer_questionnaire_prepopulation
+      title 'Questionnaires support EHR prepopulation'
+      description %(
+        Inferno verifies that, across all Questionnaires returned by the DTR server,
+        at least one includes an extension indicating support for population from
+        EHR data.
+      )
+      verifies_requirements 'hl7.fhir.us.davinci-dtr_2.2.0@spec-54'
+
+      run do
+        questionnaires = returned_questionnaires.map { |details| details[:questionnaire] }
+        skip_if questionnaires.blank?, 'No Questionnaire resources were returned'
+
+        assert questionnaires.any? { |questionnaire| questionnaire_has_prepopulation_logic?(questionnaire) },
+               'No Questionnaire included logic supporting population from the EHR.'
+      end
+
+      private
+
+      def questionnaire_has_prepopulation_logic?(questionnaire)
+        questionnaire_items(questionnaire).any? do |item|
+          item.extension.any? { |extension| POPULATION_EXPRESSION_URLS.include?(extension.url) }
+        end
+      end
+    end
+  end
+end