davinci_dtr_test_kit 0.13.0 → 0.14.1

data/lib/davinci_dtr_test_kit/endpoints/mock_ehr/questionnaire_response_endpoint.rb

@@ -0,0 +1,22 @@
+require_relative '../mock_authorization'
+
+module DaVinciDTRTestKit
+  module MockEHR
+    class QuestionnaireResponseEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        MockAuthorization.extract_client_id_from_bearer_token(request)
+      end
+
+      def make_response
+        response.status = 201
+        response.format = 'application/fhir+json'
+        response['Access-Control-Allow-Origin'] = '*'
+        response.body = request.body.string
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_ehr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  module MockEHR
+    RESOURCE_SERVER_BASE = ENV.fetch('FHIR_REFERENCE_SERVER')
+    RESOURCE_SERVER_BEARER_TOKEN = 'SAMPLE_TOKEN'
+
+    module_function
+
+    def resource_server_client
+      client = FHIR::Client.new(RESOURCE_SERVER_BASE)
+      client.set_bearer_token(RESOURCE_SERVER_BEARER_TOKEN)
+      client
+    end
+
+    def metadata(_env)
+      cs = resource_server_client.capability_statement
+      if cs.present?
+        [200, { 'Content-Type' => 'application/fhir+json', 'Access-Control-Allow-Origin' => '*' }, [cs.to_json]]
+      else
+        [500, { 'Access-Control-Allow-Origin' => '*' }, ['Unexpected error occurred while fetching metadata']]
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/full_ehr_next_question_endpoint.rb

@@ -0,0 +1,11 @@
+require_relative 'next_question_endpoint'
+
+module DaVinciDTRTestKit
+  module MockPayer
+    class FullEHRNextQuestionEndpoint < NextQuestionEndpoint
+      def test_run_identifier
+        request.headers['authorization']&.delete_prefix('Bearer ')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/full_ehr_questionnaire_package_endpoint.rb

@@ -0,0 +1,11 @@
+require_relative 'questionnaire_package_endpoint'
+
+module DaVinciDTRTestKit
+  module MockPayer
+    class FullEHRQuestionnairePackageEndpoint < QuestionnairePackageEndpoint
+      def test_run_identifier
+        request.headers['authorization']&.delete_prefix('Bearer ')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/next_question_endpoint.rb

@@ -0,0 +1,162 @@
+require_relative '../mock_authorization'
+require_relative '../mock_payer'
+require_relative '../../fixtures'
+
+module DaVinciDTRTestKit
+  module MockPayer
+    class NextQuestionEndpoint < Inferno::DSL::SuiteEndpoint
+      include MockPayer
+
+      def test_run_identifier
+        MockAuthorization.extract_client_id_from_bearer_token(request)
+      end
+
+      def tags
+        [test.config.options[:next_tag]]
+      end
+
+      def make_response
+        response.status = 200
+        response.format = 'application/fhir+json'
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.body = build_questionnaire_next_response.to_json
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
+      end
+
+      private
+
+      def evaluator
+        @evaluator ||= Inferno::DSL::FhirpathEvaluation::Evaluator.new
+      end
+
+      def build_questionnaire_next_response
+        input_parameters = parse_fhir_object(request.body.string)
+        return input_parameters if input_parameters.is_a?(FHIR::OperationOutcome)
+
+        questionnaire_response = extract_questionnaire_response(input_parameters)
+        return questionnaire_response if questionnaire_response.is_a?(FHIR::OperationOutcome)
+
+        questionnaire_response_param = FHIR::Parameters::Parameter.new(name: 'return', resource: questionnaire_response)
+
+        if questionnaire_last_dinner_order_question_present?(questionnaire_response)
+          # change the questionnaire response status to completed and return the parameters
+          return handle_last_dinner_order(questionnaire_response)
+        end
+
+        next_questionnaire = determine_next_questionnaire(questionnaire_response, test.id)
+
+        return missing_next_questionnaire_outcome(test.id) unless next_questionnaire
+
+        update_questionnaire_response(questionnaire_response, next_questionnaire)
+
+        unless questionnaire_in_questionnaire_response_exist?(questionnaire_response, next_questionnaire)
+          issue = "Questionnaire #{questionnaire_response.questionnaire} does not exist"
+          outcome_param = build_outcome_param([outcome_issue('warning', 'not-found', issue)])
+          questionnaire_response_param.name = 'return'
+          return FHIR::Parameters.new(parameter: [questionnaire_response_param, outcome_param])
+        end
+
+        questionnaire_response
+      end
+
+      def extract_questionnaire_response(input_parameters)
+        if input_parameters.is_a?(FHIR::Parameters)
+          questionnaire_response_param = find_questionnaire_response(input_parameters)
+          return questionnaire_response_param if questionnaire_response_param.is_a?(FHIR::OperationOutcome)
+
+          questionnaire_response = questionnaire_response_param.resource
+          unless valid_questionnaire_response?(questionnaire_response)
+            return invalid_next_question_param_resource_outcome
+          end
+
+          questionnaire_response
+        elsif input_parameters.is_a?(FHIR::QuestionnaireResponse)
+          input_parameters
+        else
+          operation_outcome('error', 'invalid', 'wrong resource type submitted for $next-question request.')
+        end
+      end
+
+      def valid_questionnaire_response?(questionnaire_response)
+        questionnaire_response.is_a?(FHIR::QuestionnaireResponse)
+      end
+
+      def invalid_next_question_param_resource_outcome
+        issue = 'Input `parameter:questionnaire-response.resource` is missing or not a QuestionnaireResponse.'
+        operation_outcome('error', 'business-rule', issue)
+      end
+
+      def missing_next_questionnaire_outcome(test_id)
+        operation_outcome('error', 'business-rule', "No Questionnaire found for Inferno test #{test_id}")
+      end
+
+      def update_questionnaire_response(questionnaire_response, next_questionnaire = nil)
+        if next_questionnaire
+          questionnaire_response.contained.reject! { |resource| resource.resourceType == 'Questionnaire' }
+          questionnaire_response.contained << next_questionnaire
+        else
+          questionnaire_response.status = 'completed'
+        end
+      end
+
+      def determine_next_questionnaire(questionnaire_response, test_id)
+        # Retrieve the selected option from the response and determine the next set of questions
+        if questionnaire_dinner_order_selection_present?(questionnaire_response)
+          dinner_question_from_selection(questionnaire_response, test_id)
+        else
+          Fixtures.next_question_for_test(test_id)
+        end
+      end
+
+      def handle_last_dinner_order(questionnaire_response)
+        update_questionnaire_response(questionnaire_response)
+        questionnaire_response
+      end
+
+      # Retrieve the selected option from the response and determine the next set of questions
+      def dinner_question_from_selection(questionnaire_response, test_id)
+        option = retrieve_dinner_order_selection(questionnaire_response)
+        unless option
+          issue = 'Cannot determine next question to return: Dinner order selection answer missing '
+          return operation_outcome('error', 'business-rule', issue)
+        end
+
+        Fixtures.next_question_for_test(test_id, option)
+      end
+
+      def questionnaire_in_questionnaire_response_exist?(questionnaire_response, next_questionnaire)
+        questionnaire_response.questionnaire&.include?(next_questionnaire.id)
+      end
+
+      def questionnaire_dinner_order_selection_present?(questionnaire_response)
+        # LinkId = 3.1 for the What would you like for dinner? question
+        path = "contained.where($this is Questionnaire).item.where(linkId = '3').item.where(linkId = '3.1').exists()"
+        eval_result = evaluate_fhirpath(questionnaire_response, path)
+        !!eval_result.first&.dig('element')
+      end
+
+      def questionnaire_last_dinner_order_question_present?(questionnaire_response)
+        # LinkId = 3.3 for the Any special requests? question
+        path = "contained.where($this is Questionnaire).item.where(linkId = '3').item.where(linkId = '3.3').exists()"
+        eval_result = evaluate_fhirpath(questionnaire_response, path)
+        !!eval_result.first&.dig('element')
+      end
+
+      def retrieve_dinner_order_selection(questionnaire_response)
+        # LinkId = 3.1 for the What would you like for dinner? question
+        path = "item.where(linkId = '3').item.where(linkId = '3.1').answer.where(value is Coding).value.code"
+        eval_result = evaluate_fhirpath(questionnaire_response, path)
+        elem = eval_result.first&.dig('element')
+        elem&.parameterize&.underscore
+      end
+
+      # Wrapper around evaluator call. The SuiteEndpoint isn't a runnable, so we just instantiate a dummy runnable
+      def evaluate_fhirpath(fhir_resource, fhirpath_expression)
+        evaluator.evaluate_fhirpath(fhir_resource, fhirpath_expression, Inferno::TestSuite.new)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/next_question_proxy_endpoint.rb

@@ -0,0 +1,36 @@
+module DaVinciDTRTestKit
+  module MockPayer
+    class NextQuestionProxyEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        request.headers['authorization']&.delete_prefix('Bearer ')
+      end
+
+      def tags
+        [NEXT_TAG]
+      end
+
+      def make_response
+        session_id = result.test_session_id
+        session_data = Inferno::Repositories::SessionData.new
+        url_input = session_data.load(test_session_id: session_id, name: 'url')
+        credentials_input = session_data.load(test_session_id: session_id, name: 'credentials',
+                                              type: 'oauth_credentials')
+
+        client = FHIR::Client.new(url_input)
+        client.default_json
+        client.set_bearer_token(credentials_input.access_token) if credentials_input.access_token
+        payer_response = client.send(:post, '/Questionnaire/$next-question', JSON.parse(request.body.string),
+                                     { 'Content-Type' => 'application/fhir+json' })
+
+        response.status = 200
+        response.format = 'application/fhir+json'
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.body = payer_response.response[:body].to_s
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/questionnaire_package_endpoint.rb

@@ -0,0 +1,62 @@
+require_relative '../mock_authorization'
+require_relative '../mock_payer'
+require_relative '../../fixtures'
+
+module DaVinciDTRTestKit
+  module MockPayer
+    class QuestionnairePackageEndpoint < Inferno::DSL::SuiteEndpoint
+      include MockPayer
+
+      def test_run_identifier
+        MockAuthorization.extract_client_id_from_bearer_token(request)
+      end
+
+      def tags
+        [QUESTIONNAIRE_PACKAGE_TAG]
+      end
+
+      def make_response
+        response.status = 200
+        response.format = 'application/fhir+json'
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.body = build_questionnaire_package_response.to_json
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
+      end
+
+      private
+
+      def build_questionnaire_package_response
+        input_parameters = parse_fhir_object(request.body.string)
+        return input_parameters if input_parameters.is_a?(FHIR::OperationOutcome)
+
+        questionnaire_package = Fixtures.questionnaire_package_for_test(test.id)
+        unless questionnaire_package
+          return operation_outcome('error', 'business-rule', "No Questionnaire found for Inferno test #{test.id}")
+        end
+
+        questionnaire_canonical = find_questionnaire_canonical(questionnaire_package)
+
+        other_questionnaire_params = input_parameters.parameter.filter do |param|
+          param.name == 'questionnaire' && param.valueCanonical != questionnaire_canonical
+        end
+
+        return questionnaire_package unless other_questionnaire_params.any?
+
+        package_bundle_param = FHIR::Parameters::Parameter.new(name: 'PackageBundle', resource: questionnaire_package)
+        issues = other_questionnaire_params.map do |param|
+          outcome_issue('warning', 'not-found', "Questionnaire #{param.valueCanonical} does not exist")
+        end
+        outcome_param = build_outcome_param(issues)
+
+        FHIR::Parameters.new(parameter: [package_bundle_param, outcome_param])
+      end
+
+      def find_questionnaire_canonical(questionnaire_package)
+        questionnaire_package&.entry&.find { |e| e.resource.is_a?(FHIR::Questionnaire) }&.resource&.url
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer/questionnaire_package_proxy_endpoint.rb

@@ -0,0 +1,38 @@
+module DaVinciDTRTestKit
+  module MockPayer
+    class QuestionnairePackageProxyEndpoint < Inferno::DSL::SuiteEndpoint
+      def test_run_identifier
+        request.headers['authorization']&.delete_prefix('Bearer ')
+      end
+
+      def tags
+        [QUESTIONNAIRE_TAG]
+      end
+
+      def make_response
+        session_id = result.test_session_id
+        session_data = Inferno::Repositories::SessionData.new
+        endpoint_input = session_data.load(test_session_id: session_id, name: 'custom_endpoint')
+        url_input = session_data.load(test_session_id: session_id, name: 'url')
+        credentials_input = session_data.load(test_session_id: session_id, name: 'credentials',
+                                              type: 'oauth_credentials')
+
+        client = FHIR::Client.new(url_input)
+        client.default_json
+        client.set_bearer_token(credentials_input.access_token) if credentials_input.access_token
+        endpoint = endpoint_input.nil? ? '/Questionnaire/$questionnaire-package' : endpoint_input
+        payer_response = client.send(:post, endpoint, JSON.parse(request.body.string),
+                                     { 'Content-Type' => 'application/fhir+json' })
+
+        response.status = 200
+        response.format = 'application/fhir+json'
+        response.headers['Access-Control-Allow-Origin'] = '*'
+        response.body = payer_response.response[:body].to_s
+      end
+
+      def update_result
+        results_repo.update_result(result.id, 'pass') unless test.config.options[:accepts_multiple_requests]
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/endpoints/mock_payer.rb

@@ -0,0 +1,36 @@
+module DaVinciDTRTestKit
+  module MockPayer
+    def parse_fhir_object(str)
+      FHIR.from_contents(str)
+    rescue StandardError
+      operation_outcome('error', 'invalid', 'No valid input parameters')
+    end
+
+    def find_questionnaire_response(input_parameters)
+      questionnaire_response_param = input_parameters.try(&:parameter)&.find do |param|
+        param.name == 'questionnaire-response'
+      end
+      return questionnaire_response_param if questionnaire_response_param
+
+      operation_outcome('error', 'business-rule',
+                        'Input parameter does not have a `parameter:questionnaire-response` slice.')
+    end
+
+    def build_outcome_param(issues)
+      FHIR::Parameters::Parameter.new(
+        name: 'Outcome',
+        resource: FHIR::OperationOutcome.new(issue: issues)
+      )
+    end
+
+    def operation_outcome(severity, code, text = nil)
+      FHIR::OperationOutcome.new(issue: outcome_issue(severity, code, text))
+    end
+
+    def outcome_issue(severity, code, text = nil)
+      FHIR::OperationOutcome::Issue.new(severity:, code:).tap do |issue|
+        issue.details = FHIR::CodeableConcept.new(text:) if text.present?
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/dinner_order_adaptive_next_question_burrito.json

@@ -4,9 +4,14 @@
   "meta": {
     "profile": [
       "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
-      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt"
+      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt",
+      "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-adapt"
     ]
   },
+  "text": {
+    "status": "generated",
+    "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\">This is an adaptive questionnaire used to determine what a patient would like for dinner, including pre-populated patient information.</div>"
+  },
   "extension": [
     {
       "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-questionnaireAdaptive",
@@ -17,6 +22,9 @@
       "valueCanonical": "https://madie.cms.gov/Library/DTRTest"
     }
   ],
+  "derivedFrom": [
+    "urn:inferno:dtr-test-kit:dinner-order-adaptive"
+  ],
   "name": "DinnerOrderAdaptive",
   "title": "Dinner Order (Adaptive)",
   "status": "draft",
@@ -167,4 +175,4 @@
       ]
     }
   ]
-}
+}

data/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/dinner_order_adaptive_next_question_hamburger.json

@@ -4,9 +4,14 @@
   "meta": {
     "profile": [
       "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
-      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt"
+      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt",
+      "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-adapt"
     ]
   },
+  "text": {
+    "status": "generated",
+    "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\">This is an adaptive questionnaire used to determine what a patient would like for dinner, including pre-populated patient information.</div>"
+  },
   "extension": [
     {
       "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-questionnaireAdaptive",
@@ -17,6 +22,9 @@
       "valueCanonical": "https://madie.cms.gov/Library/DTRTest"
     }
   ],
+  "derivedFrom": [
+    "urn:inferno:dtr-test-kit:dinner-order-adaptive"
+  ],
   "name": "DinnerOrderAdaptive",
   "title": "Dinner Order (Adaptive)",
   "status": "draft",
@@ -172,4 +180,4 @@
       ]
     }
   ]
-}
+}

data/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/dinner_order_adaptive_next_question_initial.json

@@ -4,9 +4,14 @@
   "meta": {
     "profile": [
       "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
-      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt"
+      "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt",
+      "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-adapt"
     ]
   },
+  "text": {
+    "status": "generated",
+    "div": "<div xmlns=\"http://www.w3.org/1999/xhtml\">This is an adaptive questionnaire used to determine what a patient would like for dinner, including pre-populated patient information.</div>"
+  },
   "extension": [
     {
       "url": "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-questionnaireAdaptive",
@@ -17,6 +22,9 @@
       "valueCanonical": "https://madie.cms.gov/Library/DTRTest"
     }
   ],
+  "derivedFrom": [
+    "urn:inferno:dtr-test-kit:dinner-order-adaptive"
+  ],
   "name": "DinnerOrderAdaptive",
   "title": "Dinner Order (Adaptive)",
   "status": "draft",
@@ -137,4 +145,4 @@
       ]
     }
   ]
-}
+}

data/lib/davinci_dtr_test_kit/fixtures/dinner_adaptive/questionnaire_dinner_order_adaptive.json

@@ -5,10 +5,12 @@
       "resource": {
         "resourceType": "Questionnaire",
         "id": "DinnerOrderAdaptive",
+        "url": "urn:inferno:dtr-test-kit:dinner-order-adaptive",
         "meta": {
           "profile": [
             "http://hl7.org/fhir/StructureDefinition/cqf-questionnaire",
-            "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search"
+            "http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search",
+            "http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-adapt"
           ]
         },
         "extension": [
@@ -23,7 +25,6 @@
         ],
         "name": "DinnerOrderAdaptive",
         "title": "Dinner Order (Adaptive)",
-        "url": "urn:inferno:dtr-test-kit:dinner-order-adaptive",
         "status": "draft",
         "subjectType": [
           "Patient"
@@ -92,4 +93,4 @@
       }
     }
   ]
-}
+}

data/lib/davinci_dtr_test_kit/fixtures.rb

@@ -21,6 +21,23 @@ module DaVinciDTRTestKit
         ],
         questionnaire_package: File.join('dinner_static', 'questionnaire_dinner_order_static.json'),
         questionnaire_response: File.join('dinner_static', 'questionnaire_response_dinner_order_static.json')
+      },
+      {
+        group_ids: [
+          'dtr_full_ehr_adaptive_questionnaire_retrieval',
+          'dtr_smart_app_adaptive_questionnaire_retrieval'
+        ],
+        questionnaire_package: File.join('dinner_adaptive', 'questionnaire_dinner_order_adaptive.json'),
+        next_question: File.join('dinner_adaptive', 'dinner_order_adaptive_next_question_initial.json')
+      },
+      {
+        group_ids: [
+          'dtr_adaptive_questionnaire_followup_questions'
+        ],
+        next_question: {
+          bean_burrito: File.join('dinner_adaptive', 'dinner_order_adaptive_next_question_burrito.json'),
+          hamburger: File.join('dinner_adaptive', 'dinner_order_adaptive_next_question_hamburger.json')
+        }
       }
     ].freeze
 
@@ -31,6 +48,11 @@ module DaVinciDTRTestKit
       get_fixture(full_test_id, :questionnaire_package)
     end
 
+    # full_test_id needs to be the long inferno-generated ID that includes hyphenated ancestor IDs
+    def next_question_for_test(full_test_id, option = nil)
+      get_fixture(full_test_id, :next_question, option)
+    end
+
     # full_test_id needs to be the long inferno-generated ID that includes hyphenated ancestor IDs
     def questionnaire_response_for_test(full_test_id)
       get_fixture(full_test_id, :questionnaire_response)
@@ -43,10 +65,11 @@ module DaVinciDTRTestKit
 
     private
 
-    def get_fixture(full_test_id, fixture_type)
+    def get_fixture(full_test_id, fixture_type, option = nil)
       fixture_path = extract_group_ids(full_test_id).filter_map do |group_id|
         FIXTURE_CONFIG.find { |fc| fc[:group_ids].include?(group_id) }&.dig(fixture_type)
       end&.first
+      fixture_path = fixture_path[option.to_sym] if option && fixture_path.is_a?(Hash)
 
       FixtureLoader.instance[fixture_path]
     end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_libraries_test.rb

@@ -12,8 +12,8 @@ module DaVinciDTRTestKit
 
     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])
+      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      check_libraries(scratch[:adaptive_questionnaire_bundles])
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_expressions_test.rb

@@ -12,9 +12,10 @@ module DaVinciDTRTestKit
 
     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
+      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      questionnaires = extract_questionnaires_from_bundles(scratch[:adaptive_questionnaire_bundles])
+      verify_questionnaire_items(questionnaires)
+      scratch[:adaptive_questionnaire_bundles] = nil
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_extensions_test.rb

@@ -12,8 +12,9 @@ module DaVinciDTRTestKit
 
     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])
+      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      questionnaires = extract_questionnaires_from_bundles(scratch[:adaptive_questionnaire_bundles])
+      verify_questionnaire_extensions(questionnaires)
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_expressions_test.rb

@@ -1,10 +1,10 @@
 require_relative '../cql_test'
 module DaVinciDTRTestKit
-  class PayerStaticFormExpressionsTest < Inferno::Test
+  class PayerAdaptiveNextQuestionExpressionsTest < 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'
+    id :dtr_v201_payer_adaptive_next_question_expressions_test
+    title 'Adaptive Next Question questionnaire(s) contain items with expressions necessary for pre-population'
     description %(
       Inferno checks that the payer server response to $next-question operation has appropriate expressions and that
       expressions are written in cql.
@@ -12,9 +12,9 @@ module DaVinciDTRTestKit
 
     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
+      skip_if scratch[:next_question_questionnaire_responses].nil?, 'No questionnaires returned.'
+      questionnaires = extract_contained_questionnaires(scratch[:next_question_questionnaire_responses])
+      verify_questionnaire_items(questionnaires, final_cql_test: true)
     end
   end
 end