davinci_dtr_test_kit 0.9.0

data/lib/davinci_dtr_test_kit/fixtures.rb

@@ -0,0 +1,65 @@
+require_relative 'fixture_loader'
+
+module DaVinciDTRTestKit
+  module Fixtures
+    DATA_REQUIREMENT_ANSWERS = { 'RAD Prepopulation' => '3.1' }.freeze
+
+    def get_questionnaire_package_for_group_id(group_id)
+      FixtureLoader.instance.questionnaire_package_for_group_id(group_id)
+    end
+
+    def find_questionnaire_instance_for_test_id(test_id)
+      canonical_url = find_questionnaire_canonical_for_test_id(test_id)
+      return unless canonical_url.present?
+
+      package = get_questionnaire_packcage_for_canonical(canonical_url)
+      return unless package.present?
+
+      questionnaire = nil
+      package.entry.find do |entry|
+        questionnaire = entry.resource if entry.resource.is_a?(FHIR::Questionnaire)
+      end
+      questionnaire
+    end
+
+    def find_questionnaire_canonical_for_test_id(test_id)
+      canonical_url = nil
+
+      # test_id is of the form [suite id]-[group id 1]-...-[group id n]-[test id]
+      groups = test_id.split('-')[1..-2] # first is suite, last is test, we want groups
+      groups.each do |one_group_id|
+        next if canonical_url.present?
+
+        canonical_url = get_questionnaire_canonical_for_group_id(one_group_id)
+      end
+
+      canonical_url
+    end
+
+    def get_questionnaire_canonical_for_group_id(group_id)
+      FixtureLoader.instance.questionnaire_canonical_for_group_id(group_id)
+    end
+
+    def get_questionnaire_packcage_for_canonical(url)
+      FixtureLoader.instance.questionnaire_package_for_canonical(url)
+    end
+
+    def find_questionnaire_response_for_test_id(test_id)
+      questionnaire_response = nil
+
+      # test_id is of the form [suite id]-[group id 1]-...-[group id n]-[test id]
+      groups = test_id.split('-')[1..-2] # first is suite, last is test, we want groups
+      groups.each do |one_group_id|
+        next if questionnaire_response.present?
+
+        questionnaire_response = get_questionnaire_response_for_group_id(one_group_id)
+      end
+
+      questionnaire_response
+    end
+
+    def get_questionnaire_response_for_group_id(group_id)
+      FixtureLoader.instance.questionnaire_response_for_group_id(group_id)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/mock_ehr.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  module MockEHR
+    RESOURCE_SERVER_BASE = ENV.fetch('FHIR_REFERENCE_SERVER')
+    RESOURCE_SERVER_BEARER_TOKEN = 'SAMPLE_TOKEN'
+
+    RESPONSE_HEADERS = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }.freeze
+
+    def resource_server_client
+      return @resource_server_client if @resource_server_client
+
+      client = FHIR::Client.new(RESOURCE_SERVER_BASE)
+      client.set_bearer_token(RESOURCE_SERVER_BEARER_TOKEN)
+      @resource_server_client = client
+    end
+
+    def metadata_handler(_env)
+      cs = resource_server_client.capability_statement
+      if cs.present?
+        [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [cs.to_json]]
+      else
+        [500, {}, ['Unexpected error occurred while fetching metadata']]
+      end
+    end
+
+    def get_fhir_resource(request, _test = nil, _test_result = nil)
+      resource_type, id = resource_type_and_id_from_url(request.url)
+      request.response_headers = RESPONSE_HEADERS
+
+      begin
+        fhir_class = FHIR.const_get(resource_type)
+      rescue NameError
+        resource_type = nil
+      end
+
+      if resource_type.present?
+        response = if id.present?
+                     resource_server_client.read(fhir_class, id)
+                   else
+                     resource_server_client.search(fhir_class, search: { parameters: request.query_parameters })
+                   end
+        request.status = response.code
+        request.response_body = response.body
+      else
+        request.status = 400
+        request.response_headers = { 'Content-Type': 'application/json' }
+        request.response_body = FHIR::OperationOutcome.new(
+          issue: FHIR::OperationOutcome::Issue.new(severity: 'warning', code: 'not-supported',
+                                                   details: FHIR::CodeableConcept.new(
+                                                     text: 'No recognized resource type in URL'
+                                                   ))
+        ).to_json
+      end
+    end
+
+    def questionnaire_response_response(request, _test = nil, _test_result = nil)
+      request.status = 201
+      request.response_headers = RESPONSE_HEADERS
+      request.response_body = request.request_body
+    end
+
+    # Pull resource type and ID from url
+    # e.g. http://example.org/fhir/Patient/123 -> ['Patient', '123']
+    # @private
+    def resource_type_and_id_from_url(url)
+      path = url.split('?').first.split('/fhir/').second
+      path.sub!(%r{/$}, '')
+      path.split('/')
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/mock_payer.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative 'fixtures'
+
+module DaVinciDTRTestKit
+  module MockPayer
+    include Fixtures
+
+    RESPONSE_HEADERS = { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }.freeze
+
+    def token_response(request, _test = nil, _test_result = nil)
+      # Placeholder for a more complete mock token endpoint
+      request.response_body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 300 }.to_json
+      request.status = 200
+    end
+
+    def questionnaire_package_response(request, _test = nil, test_result = nil)
+      request.status = 200
+      request.response_headers = RESPONSE_HEADERS
+      request.response_body = build_package_questionnaire_response(request, test_result.test_id).to_json
+    end
+
+    def payer_questionnaire_response(request, _test = nil, test_result = nil)
+      endpoint_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'custom_endpoint' }
+      url_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'url' }
+      client = FHIR::Client.new(url_input['value'])
+      client.default_json
+      endpoint = endpoint_input['value'].nil? ? '/Questionnaire/$questionnaire-package' : endpoint_input['value']
+      payer_response = client.send(:post, endpoint, JSON.parse(request.request_body),
+                                   { 'Content-Type' => 'application/json' })
+
+      request.status = 200
+      request.response_headers = RESPONSE_HEADERS
+      request.response_body = payer_response.response[:body].to_s
+    end
+
+    def questionnaire_next_response(request, _test = nil, test_result = nil)
+      url_endpoint = JSON.parse(test_result.input_json).find { |input| input['name'] == 'url' }
+      client = FHIR::Client.new(url_endpoint['value'])
+      client.default_json
+      payer_response = client.send(:post, '/Questionnaire/$next-question', JSON.parse(request.request_body),
+                                   { 'Content-Type' => 'application/json' })
+
+      request.status = 200
+      request.response_headers = RESPONSE_HEADERS
+
+      request.response_body = payer_response.response[:body]
+    end
+
+    def extract_client_id(request)
+      URI.decode_www_form(request.request_body).to_h['client_id']
+    end
+
+    # Header expected to be a bearer token of the form "Bearer: <token>"
+    def extract_bearer_token(request)
+      request.request_header('Authorization')&.value&.split&.last
+    end
+
+    def extract_token_from_query_params(request)
+      request.query_parameters['token']
+    end
+
+    def test_resumes?(test)
+      !test.config.options[:accepts_multiple_requests]
+    end
+
+    def build_package_questionnaire_response(request, test_id)
+      test_questionnaire_canonical = find_questionnaire_canonical_for_test_id(test_id)
+      test_questionnaire_loaded = false
+
+      bundles = []
+      issues = []
+
+      # first try the parameters - load the questionnaire specified by the questionnaire parameter
+      input_parameters = FHIR.from_contents(request.request_body)
+      input_parameters.parameter.each do |one_parameter|
+        next unless one_parameter.name == 'questionnaire'
+        next unless one_parameter.valueCanonical
+
+        # don't load test questionnaire if it is also specified explicitly
+        test_questionnaire_loaded = true if one_parameter.valueCanonical == test_questionnaire_canonical
+
+        add_questionnaire_canonical_to_response(one_parameter.valueCanonical, bundles, issues)
+      end
+
+      unless test_questionnaire_loaded
+        if test_questionnaire_canonical
+          add_questionnaire_canonical_to_response(test_questionnaire_canonical, bundles, issues)
+
+        elsif bundles.empty?
+          # no questionnaire for this test ...
+          operation_outcome_issue = FHIR::OperationOutcome::Issue.new
+          operation_outcome_issue.severity = 'error'
+          operation_outcome_issue.code = 'business-rule'
+          details = FHIR::CodeableConcept.new
+          details.text = "no questionnaire found for test #{test_id}"
+          operation_outcome_issue.details = details
+          issues << operation_outcome_issue
+        end
+      end
+
+      build_package_questionnaire_response_from_lists(bundles, issues)
+    end
+
+    def add_questionnaire_canonical_to_response(questionnaire_canonical, bundles, issues)
+      questionnaire_bundle = get_questionnaire_packcage_for_canonical(questionnaire_canonical)
+
+      if questionnaire_bundle
+        bundles << questionnaire_bundle
+      else
+        operation_outcome_issue = FHIR::OperationOutcome::Issue.new
+        operation_outcome_issue.severity = 'warning'
+        operation_outcome_issue.code = 'value'
+        details = FHIR::CodeableConcept.new
+        details.text = "Questionnaire Canonical #{questionnaire_canonical} does not exist"
+        operation_outcome_issue.details = details
+        issues << operation_outcome_issue
+      end
+    end
+
+    def build_package_questionnaire_response_from_lists(bundles, issues)
+      response = FHIR::Parameters.new
+      bundles.each do |one_bundle|
+        return_param = FHIR::Parameters::Parameter.new
+        return_param.name = 'return'
+        return_param.resource = one_bundle
+        response.parameter << return_param
+      end
+
+      unless issues.empty?
+        outcome = FHIR::OperationOutcome.new
+        outcome.issue = issues
+        outcome_param = FHIR::Parameters::Parameter.new
+        outcome_param.name = 'outcome'
+        outcome_param.resource = outcome
+        response.parameter << outcome_param
+      end
+
+      response
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_libraries_test.rb

@@ -0,0 +1,19 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormLibrariesTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_adaptive_form_libraries_test
+    title 'Parameters contain libraries necessary for pre-population'
+    description %(
+      Inferno check that the payer response contains no duplicate library names
+       and that libraries contain cql and elm data.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      skip_if scratch[:adaptive_responses].nil?, 'No questionnaire bundle returned.'
+      check_libraries(scratch[:adaptive_responses])
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_expressions_test.rb

@@ -0,0 +1,20 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormExpressionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_adaptive_form_expressions_test
+    title 'Questionnaire(s) contains items with expressions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate expressions and that expressions are
+       written in cql.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      skip_if scratch[:adaptive_responses].nil?, 'No questionnaire bundle returned.'
+      questionnaire_items_test(scratch[:adaptive_responses], final_cql_test: false)
+      scratch[:adaptive_responses] = nil
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_extensions_test.rb

@@ -0,0 +1,19 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormExtensionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_adaptive_form_extensions_test
+    title 'Questionnaire(s) contains extensions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate extensions and references to libraries within
+      those extensions.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      skip_if scratch[:adaptive_responses].nil?, 'No questionnaire bundle returned.'
+      questionnaire_extensions_test(scratch[:adaptive_responses])
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_expressions_test.rb

@@ -0,0 +1,20 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormExpressionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_adaptive_next_form_expressions_test
+    title 'Questionnaire(s) contains items with expressions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate expressions and that expressions are
+       written in cql.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      skip_if scratch[:next_responses].nil?, 'No questionnaires returned.'
+      questionnaire_items_test(scratch[:next_responses], final_cql_test: true)
+      scratch[:next_responses] = nil
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_extensions_test.rb

@@ -0,0 +1,19 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormExtensionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_adaptive_next_form_extensions_test
+    title 'Questionnaire(s) contains extensions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate extensions and references to libraries within
+      those extensions.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      skip_if scratch[:next_responses].nil?, 'No questionnaires returned.'
+      questionnaire_extensions_test(scratch[:next_responses])
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_group.rb

@@ -0,0 +1,88 @@
+require_relative 'payer_server_adaptive_request_test'
+require_relative 'payer_server_adaptive_request_validation_test'
+require_relative 'payer_server_adaptive_response_bundles_validation_test'
+require_relative 'payer_server_adaptive_response_search_validation_test'
+require_relative 'payer_server_adaptive_response_validation_test'
+require_relative 'payer_server_next_request_validation_test'
+require_relative 'payer_server_next_response_validation_test'
+require_relative 'payer_server_next_response_complete_test'
+require_relative 'adaptive_form_libraries_test'
+require_relative 'adaptive_form_questionnaire_extensions_test'
+require_relative 'adaptive_form_questionnaire_expressions_test'
+require_relative 'adaptive_next_questionnaire_extensions_test'
+require_relative 'adaptive_next_questionnaire_expressions_test'
+
+module DaVinciDTRTestKit
+  class DTRPayerServerAdaptiveQuestionnairePackageGroup < Inferno::TestGroup
+    title 'Adaptive Questionnaire Retrieval'
+    description %(
+
+      ## Background
+
+      These tests validate the ability of the Payer Server to provide an adaptive questionnaire
+       following requests from the DTR Client. Resources are validated as specified
+       in the DTR v2.0.1 Implementation Guide.
+
+      There are several input options, which correspond to different workflows. No inputs are explicitly required,
+       but all inputs for at least one work flow must be provided to complete testing (see below).
+
+      ## Testing Work Flow Options
+
+      - Enter the `FHIR Server Base Url` and `Access Token` if you are connecting a client that will provide
+       inferno with requests to be tested and sent to the server under test. These inputs must align with
+       the configuration of the DTR client being used to provide requests. Optionally,
+       an `Endpoint for a Particular Adaptive Resource` can also be provided, which should include the ID
+       of the resource of interest (e.g., `/Questionnaire/HomeOxygenTherapyAdditional/$questionnaire-package`).
+
+      - Enter the `Initial Adaptive Questionnaire Request` and a set of  `Next Question Requests`, in addition to the
+      `FHIR Server Base Url` pointing to the payer server,
+      to provide the json requests manually, rather than relying on a DTR client.
+    )
+    id :payer_server_adaptive_questionnaire
+    run_as_group
+
+    input :initial_adaptive_questionnaire_request,
+          optional: true,
+          title: 'Initial Adaptive Questionnaire Request',
+          description: 'Manual Flow',
+          type: 'textarea'
+
+    input :next_question_requests,
+          optional: true,
+          title: 'Next Question Requests',
+          description: 'Manual Flow',
+          type: 'textarea'
+
+    input_order :retrieval_method,
+                :url,
+                :custom_endpoint,
+                :access_token,
+                :initial_adaptive_questionnaire_request,
+                :next_question_requests,
+                :credentials
+
+    # receive client request
+    test from: :payer_server_questionnaire_request,
+         receives_request: :client_questionnaire_package
+
+    # optionally validate client request
+    test from: :payer_server_adaptive_questionnaire_request_validation
+
+    # pass request to payer server, validate questionnaire response
+    test from: :payer_server_adaptive_response_validation_test
+    test from: :dtr_v201_payer_adaptive_form_libraries_test
+    test from: :dtr_v201_payer_adaptive_form_extensions_test
+    test from: :dtr_v201_payer_adaptive_form_expressions_test
+    test from: :payer_server_adaptive_response_bundles_validation_test
+    test from: :payer_server_adaptive_response_search_validation_test
+
+    # optionally validate the client request
+    test from: :payer_server_next_request_validation
+
+    # pass request to payer server, validate adaptive questionnaire response
+    test from: :payer_server_next_response_validation_test
+    test from: :dtr_v201_payer_adaptive_next_form_extensions_test
+    test from: :dtr_v201_payer_adaptive_next_form_expressions_test
+    test from: :payer_server_adaptive_completion_test
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_request_test.rb

@@ -0,0 +1,41 @@
+require_relative '../urls'
+
+module DaVinciDTRTestKit
+  class AdaptiveFormTest < Inferno::Test
+    include URLs
+    title 'Confirm the client completes the DTR Adaptive Questionnaire work flow'
+    description %(
+      Inferno will wait for a DTR questionnaire package request from the client. Upon receipt, Inferno will generate and
+      send a response.
+    )
+    id :payer_server_questionnaire_request
+    config options: { accepts_multiple_requests: true }
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      pass_if !(initial_adaptive_questionnaire_request.nil? || next_question_requests.nil?),
+              'Proceeding with manually provided resources.'
+      skip_if access_token.nil?, 'Please provide an access token or all request resources as inputs.'
+      wait(
+        identifier: access_token,
+        message: %(
+          **Adaptive Form Testing**
+
+          Invoke the DTR Questionnaire Package operation by sending a POST request to
+
+          `#{questionnaire_package_url}`
+
+          and Next Question operations by sending POST requests to
+
+          `#{next_url}`
+
+
+          A set of questionnaire packages generated by Inferno will be returned. Each of the following tests
+          will validate all resources, marking messages in the order they are received.
+
+          **[click here](#{resume_pass_url}?token=#{access_token})** when the adaptive forms have been completed.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_request_validation_test.rb

@@ -0,0 +1,44 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormRequestTest < Inferno::Test
+    include URLs
+    include DaVinciDTRTestKit::ValidationTest
+    title '[USER INPUT VALIDATION] Questionnaire Package request is valid'
+    description %(
+      This test validates the conformance of the client's request to the
+      [DTR Questionnaire Package Input Parameters](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+    id :payer_server_adaptive_questionnaire_request_validation
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      if initial_adaptive_questionnaire_request.nil?
+        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
+        using_manual_entry = false
+      else
+        resources = initial_adaptive_questionnaire_request
+        using_manual_entry = true
+      end
+      skip_if resources.nil?, 'No request resources to validate.'
+      perform_request_validation_test(
+        resources,
+        :parameters,
+        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters',
+        questionnaire_package_url,
+        using_manual_entry
+      )
+    rescue Inferno::Exceptions::AssertionException => e
+      msg = e.message.to_s.strip
+      skip msg
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_bundles_validation_test.rb

@@ -0,0 +1,40 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormResponseBundlesTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+    id :payer_server_adaptive_response_bundles_validation_test
+    title 'Validate that the adaptive response contains valid Questionnaire Bundle resources'
+    description %(
+      This test ensures that the payer's response includes a resource that conforms to the the
+      [DTR Quesitonnaire Bundle](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      test_passed = false
+      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle'
+      assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
+      scratch[:adaptive_responses].each_with_index do |resource, index|
+        fhir_resource = FHIR.from_contents(resource.response[:body])
+        fhir_resource.parameter.each do |param|
+          resource_is_valid = validate_resource(param.resource, :bundle, profile_url, index)
+          test_passed = true if resource_is_valid
+        rescue StandardError
+          next
+        end
+      end
+      raise tests_failed[profile_url][0] if !test_passed && !tests_failed[profile_url].blank?
+
+      messages.clear if test_passed
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_search_validation_test.rb

@@ -0,0 +1,42 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormResponseSearchTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+    id :payer_server_adaptive_response_search_validation_test
+    title 'Validate that the adaptive response contains valid a Adaptive Form Search resource'
+    description %(
+      This test validates the conformance of the payer's response to the
+      [DTR Questionnaire for Adaptive Form Search](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      test_passed = false
+      profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search'
+      assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
+      scratch[:adaptive_responses].each_with_index do |resource, index|
+        fhir_resource = FHIR.from_contents(resource.response[:body])
+        fhir_resource.parameter.each do |param|
+          param.resource.entry.each do |entry|
+            resource_is_valid = validate_resource(entry.resource, :questionnaire, profile_url, index)
+            test_passed = true if resource_is_valid
+          end
+        rescue StandardError
+          next
+        end
+      end
+      raise tests_failed[profile_url][0] if !test_passed && !tests_failed[profile_url].blank?
+
+      messages.clear if test_passed
+    end
+  end
+end