davinci_dtr_test_kit 0.14.2 → 0.15.1

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/{dtr_smart_app_questionnaire_workflow_group.rb → dtr_smart_app_adaptive_dinner_workflow_group.rb}

@@ -1,13 +1,14 @@
 require_relative '../../tags'
-require_relative 'dtr_smart_app_adaptive_questionnaire_initial_retrieval_group'
+require_relative 'dtr_smart_app_adaptive_initial_retrieval_group'
 require_relative '../smart_app/dtr_smart_app_prepopulation_attestation_test'
 require_relative '../smart_app/dtr_smart_app_prepopulation_override_attestation_test'
-require_relative 'dtr_adaptive_questionnaire_followup_questions_group'
-require_relative 'dtr_adaptive_questionnaire_completion_group'
+require_relative 'dtr_adaptive_followup_questions_group'
+require_relative 'dtr_adaptive_completion_group'
+require_relative '../shared/dtr_questionnaire_response_prepopulation_test'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppAdaptiveDinnerQuestionnaireWorkflowGroup < Inferno::TestGroup
-    id :dtr_smart_app_adaptive_dinner_questionnaire_workflow
+  class DTRSmartAppAdaptiveDinnerWorkflowGroup < Inferno::TestGroup
+    id :dtr_smart_app_adaptive_dinner_workflow
     title 'Adaptive Questionnaire Workflow'
     description %(
       This test validates that a DTR SMART App client can perform a full DTR Adaptive Questionnaire workflow
@@ -32,7 +33,7 @@ module DaVinciDTRTestKit
     )
 
     group do
-      id :dtr_smart_app_adaptive_questionnaire_retrieval
+      id :dtr_smart_app_adaptive_retrieval
       title 'Retrieving the Adaptive Questionnaire'
       description %(
         Inferno will wait for the client system to request a questionnaire using the
@@ -45,25 +46,25 @@ module DaVinciDTRTestKit
       )
       run_as_group
 
-      group from: :dtr_smart_app_adaptive_questionnaire_initial_retrieval
+      group from: :dtr_smart_app_adaptive_initial_retrieval
       group do
         id :dtr_smart_app_initial_questionnaire_rendering
         title 'Filling Out the Questionnaire'
         description %(
           The tester will interact with the questionnaire within their client system
-          such that pre-population steps are taken, the qustionnaire is rendered, and
+          such that pre-population steps are taken, the questionnaire is rendered, and
           they are able to fill it out. The tester will attest that questionnaire pre-population
           and rendering directives were followed.
         )
 
         # Test 1: attest to the pre-population of the name fields
-        test from: :dtr_smart_app_prepopulation_attestation
+        test from: :dtr_smart_app_prepopulation_attest
         # Test 2: attest to the pre-population and edit of the location field
-        test from: :dtr_smart_app_prepopulation_override_attestation
+        test from: :dtr_smart_app_prepopulation_override_attest
       end
     end
 
-    group from: :dtr_adaptive_questionnaire_followup_questions,
+    group from: :dtr_adaptive_followup_questions,
           config: {
             options: {
               accepts_multiple_requests: true,
@@ -74,7 +75,7 @@ module DaVinciDTRTestKit
             }
           }
 
-    group from: :dtr_adaptive_questionnaire_completion,
+    group from: :dtr_adaptive_completion,
           config: {
             options: {
               accepts_multiple_requests: true,
@@ -84,12 +85,17 @@ module DaVinciDTRTestKit
               access_token: { name: :client_id }
             }
           }
-    group from: :dtr_smart_app_saving_questionnaire_response,
-          config: {
-            options: {
-              adaptive: true,
-              qr_profile_url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt'
-            }
-          }
+    group from: :dtr_smart_app_saving_qr do
+      config(
+        options: {
+          adaptive: true,
+          qr_profile_url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt'
+        }
+      )
+
+      # Test 3: validate workflow-specific details such as pre-population and overrides
+      test from: :dtr_qr_prepopulation,
+           uses_request: :questionnaire_response_save
+    end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/dtr_smart_app_adaptive_initial_retrieval_group.rb

@@ -0,0 +1,24 @@
+require_relative '../../tags'
+require_relative 'dtr_smart_app_adaptive_request_test'
+require_relative '../shared/dtr_questionnaire_package_request_validation_test'
+require_relative 'dtr_adaptive_next_question_request_validation_test'
+require_relative 'dtr_adaptive_response_validation_test'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppAdaptiveInitialRetrievalGroup < Inferno::TestGroup
+    id :dtr_smart_app_adaptive_initial_retrieval
+    title 'Adaptive Questionnaire Package and Initial Questions Retrieval'
+
+    config(options: { next_tag: "initial_#{CLIENT_NEXT_TAG}" })
+    run_as_group
+
+    # Test 1: wait for the $questionnaire-package request and initial $next-question request
+    test from: :dtr_smart_app_adaptive_request
+    # Test 2: validate the $questionnaire-package request body
+    test from: :dtr_qp_request_validation
+    # Test 3: validate the $next-question request body
+    test from: :dtr_adaptive_next_question_request_validation
+    # Test 4: validate the QuestionnaireResponse in the input parameter
+    test from: :dtr_adaptive_response_validation
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_adaptive/{dtr_smart_app_adaptive_questionnaire_request_test.rb → dtr_smart_app_adaptive_request_test.rb}

@@ -1,10 +1,10 @@
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppAdaptiveQuestionnaireRequestTest < Inferno::Test
+  class DTRSmartAppAdaptiveRequestTest < Inferno::Test
     include URLs
 
-    id :dtr_smart_app_adaptive_questionnaire_request
+    id :dtr_smart_app_adaptive_request
     title 'Invoke the Questionnaire Package and Initial Next Question Operation'
     description %(
       This test waits for two sequential client requests:

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/{dtr_full_ehr_questionnaire_workflow_group.rb → dtr_full_ehr_static_dinner_workflow_group.rb}

@@ -2,14 +2,14 @@ require_relative '../full_ehr/dtr_full_ehr_launch_attestation_test'
 require_relative '../full_ehr/dtr_full_ehr_questionnaire_package_request_test'
 require_relative '../shared/dtr_questionnaire_package_request_validation_test'
 require_relative '../full_ehr/dtr_full_ehr_prepopulation_attestation_test'
-require_relative '../full_ehr/dtr_full_ehr_rendering_enabled_questions_attestation_test'
+require_relative 'dtr_static_dinner_enabled_questions_attestation_test'
 require_relative '../full_ehr/dtr_full_ehr_prepopulation_override_attestation_test'
 require_relative '../full_ehr/dtr_full_ehr_saving_questionnaire_response_group'
 
 module DaVinciDTRTestKit
-  class DTRFullEHRStaticDinnerQuestionnaireWorkflowGroup < Inferno::TestGroup
-    id :dtr_full_ehr_static_dinner_questionnaire_workflow
-    title 'Static Questionnaire Workflow'
+  class DTRFullEHRStaticDinnerWorkflowGroup < Inferno::TestGroup
+    id :dtr_full_ehr_static_dinner_workflow
+    title 'Dinner Order Static Questionnaire Workflow'
     description %(
       This test validates that a DTR Full EHR client can perform a full DTR Static Questionnaire workflow
       using a mocked questionnaire requesting what a patient wants for dinner. The client system must
@@ -22,9 +22,10 @@ module DaVinciDTRTestKit
          - display questions only when they are enabled by other answers
       3. Complete and store the questionnaire response for future use.
     )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@35', 'hl7.fhir.us.davinci-dtr_2.0.1@208'
 
     group do
-      id :dtr_full_ehr_static_questionnaire_retrieval
+      id :dtr_full_ehr_static_retrieval
       title 'Retrieving the Static Questionnaire'
       description %(
         After DTR launch, Inferno will wait for the client system to request a questionnaire using the
@@ -34,33 +35,33 @@ module DaVinciDTRTestKit
       run_as_group
 
       # Test 0: attest to launch
-      test from: :dtr_full_ehr_launch_attestation
+      test from: :dtr_full_ehr_launch_attest
       # Test 1: wait for the $questionnaire-package request
-      test from: :dtr_full_ehr_questionnaire_package_request
+      test from: :dtr_full_ehr_qp_request
       # Test 2: validate the $questionnaire-package body
-      test from: :dtr_questionnaire_package_request_validation
+      test from: :dtr_qp_request_validation
     end
 
     group do
-      id :dtr_full_ehr_static_questionnaire_rendering
+      id :dtr_full_ehr_static_rendering
       title 'Filling Out the Static Questionnaire'
       description %(
         The tester will interact with the questionnaire within their client system
-        such that pre-population steps are taken, the qustionnaire is rendered, and
+        such that pre-population steps are taken, the questionnaire is rendered, and
         they are able to fill it out. The tester will attest that questionnaire pre-population
         and rendering directives were followed.
       )
       run_as_group
 
       # Test 1: attest to the pre-population of the name fields
-      test from: :dtr_full_ehr_prepopulation_attestation
+      test from: :dtr_full_ehr_prepopulation_attest
       # Test 2: attest to the pre-population and edit of the first name field
-      test from: :dtr_full_ehr_prepopulation_override_attestation
+      test from: :dtr_full_ehr_prepopulation_override_attest
       # Test 3: attest to the display of the toppings questions only when a dinner answer is selected
-      test from: :dtr_full_ehr_rendering_enabled_questions_attestation
+      test from: :dtr_static_dinner_enabled_questions_attest
     end
 
-    group from: :dtr_full_ehr_saving_questionnaire_response,
+    group from: :dtr_full_ehr_saving_qr,
           config: {
             inputs: {
               questionnaire_response: {

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/{dtr_smart_app_questionnaire_workflow_group.rb → dtr_smart_app_static_dinner_workflow_group.rb}

@@ -1,14 +1,15 @@
-require_relative 'dtr_smart_app_dinner_questionnaire_package_request_test'
+require_relative '../smart_app/dtr_smart_app_questionnaire_package_request_test'
 require_relative '../shared/dtr_questionnaire_package_request_validation_test'
 require_relative '../smart_app/dtr_smart_app_prepopulation_attestation_test'
 require_relative '../smart_app/dtr_smart_app_prepopulation_override_attestation_test'
-require_relative '../smart_app/dtr_smart_app_rendering_enabled_questions_attestation_test'
+require_relative 'dtr_static_dinner_enabled_questions_attestation_test'
 require_relative '../smart_app/dtr_smart_app_saving_questionnaire_response_group'
+require_relative '../shared/dtr_questionnaire_response_prepopulation_test'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppStaticDinnerQuestionnaireWorkflowGroup < Inferno::TestGroup
-    id :dtr_smart_app_static_dinner_questionnaire_workflow
-    title 'Static Questionnaire Workflow'
+  class DTRSmartAppStaticDinnerWorkflowGroup < Inferno::TestGroup
+    id :dtr_smart_app_static_dinner_workflow
+    title 'Dinner Order Static Questionnaire Workflow'
     description %(
       This test validates that a DTR SMART App client can perform a full DTR Static Questionnaire workflow
       using a mocked questionnaire requesting what a patient wants for dinner. The client system must
@@ -25,7 +26,7 @@ module DaVinciDTRTestKit
     )
 
     group do
-      id :dtr_smart_app_static_questionnaire_retrieval
+      id :dtr_smart_app_static_retrieval
       title 'Retrieving the Static Questionnaire'
       description %(
         Inferno will wait for the client system to request a questionnaire using the
@@ -35,13 +36,13 @@ module DaVinciDTRTestKit
       run_as_group
 
       # Test 1: wait for the $questionnaire-package request
-      test from: :dtr_smart_app_dinner_questionnaire_package_request
+      test from: :dtr_smart_app_qp_request
       # Test 2: validate the $questionnaire-package body
-      test from: :dtr_questionnaire_package_request_validation
+      test from: :dtr_qp_request_validation
     end
 
     group do
-      id :dtr_smart_app_static_questionnaire_rendering
+      id :dtr_smart_app_static_rendering
       title 'Filling Out the Static Questionnaire'
       description %(
         The tester will interact with the questionnaire within their client system
@@ -56,13 +57,17 @@ module DaVinciDTRTestKit
       # since the questionnaire asks them to
       # TODO: once Tom has gotten the reference server hooked up
       # Test 2: attest to the pre-population of the name fields
-      test from: :dtr_smart_app_prepopulation_attestation
+      test from: :dtr_smart_app_prepopulation_attest
       # Test 3: attest to the pre-population and edit of the location field
-      test from: :dtr_smart_app_prepopulation_override_attestation
+      test from: :dtr_smart_app_prepopulation_override_attest
       # Test 4: attest to the display of the toppings questions only when a dinner answer is selected
-      test from: :dtr_smart_app_rendering_enabled_questions_attestation
+      test from: :dtr_static_dinner_enabled_questions_attest
     end
 
-    group from: :dtr_smart_app_saving_questionnaire_response
+    group from: :dtr_smart_app_saving_qr do
+      # Test 3: validate workflow-specific details such as pre-population and overrides
+      test from: :dtr_qr_prepopulation,
+           uses_request: :questionnaire_response_save
+    end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/{full_ehr/dtr_full_ehr_rendering_enabled_questions_attestation_test.rb → dinner_static/dtr_static_dinner_enabled_questions_attestation_test.rb}

@@ -2,10 +2,10 @@ require 'securerandom'
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRFullEHRRenderingEnabledQuestionsAttestationTest < Inferno::Test
+  class DTRStaticDinnerEnabledQuestionsAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_rendering_enabled_questions_attestation
+    id :dtr_static_dinner_enabled_questions_attest
     title 'Check that the client renders enabled questions appropriately (Attestation)'
     description %(
       Validate that the rendering of the questionnaire includes only the "What would you like on..."

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_launch_attestation_test.rb

@@ -5,19 +5,24 @@ module DaVinciDTRTestKit
   class DTRFullEHRLaunchAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_launch_attestation
+    id :dtr_full_ehr_launch_attest
     title 'Launch DTR for a patient that has an official name (Attestation)'
     description %(
       Attest that DTR has been launched for a patient with data that will be used for prepopulation.
     )
 
+    def attestation_message
+      return config.options[:attestation_message] if config.options.key?(:attestation_message)
+
+      'I attest that DTR has been launched in the context of a patient with an official name, including first and last.'
+    end
+
     run do
       random_id = SecureRandom.uuid
       wait(
         identifier: random_id,
         message: %(
-          I attest that DTR has been launched in the context of a patient with an official name, including
-          first and last.
+          #{attestation_message}
 
           [Click here](#{resume_pass_url}?token=#{random_id}) if the above statement is **true**.
 

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_prepopulation_attestation_test.rb

@@ -5,11 +5,13 @@ module DaVinciDTRTestKit
   class DTRFullEHRPrepopulationAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_prepopulation_attestation
+    id :dtr_full_ehr_prepopulation_attest
     title 'Check that the client pre-populates the questionnaire (Attestation)'
     description %(
       Validate that pre-population of patient name information occurs as expected.
     )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@207'
+
     run do
       random_id = SecureRandom.uuid
       wait(

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_prepopulation_override_attestation_test.rb

@@ -5,11 +5,12 @@ module DaVinciDTRTestKit
   class DTRFullEHRPrepopulationOverrideAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_prepopulation_override_attestation
+    id :dtr_full_ehr_prepopulation_override_attest
     title 'Validate the user can override pre-populated data (Attestation)'
     description %(
       Validate that the user can edit a pre-populated item and replace it with another value.
     )
+
     run do
       random_id = SecureRandom.uuid
       wait(

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_questionnaire_package_request_test.rb

@@ -4,12 +4,13 @@ module DaVinciDTRTestKit
   class DTRFullEHRQuestionnairePackageRequestTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_questionnaire_package_request
+    id :dtr_full_ehr_qp_request
     title 'Invoke the DTR Questionnaire Package operation'
     description %(
       Inferno will wait for a DTR questionnaire package request from the client. Upon receipt, Inferno will generate and
       send a response.
     )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@165', 'hl7.fhir.us.davinci-dtr_2.0.1@262'
 
     input :access_token,
           description: %(

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_questionnaire_response_conformance_test.rb

@@ -4,8 +4,13 @@ module DaVinciDTRTestKit
   class DTRFullEHRQuestionnaireResponseConformanceTest < Inferno::Test
     include DTRQuestionnaireResponseValidation
 
-    id :dtr_full_ehr_questionnaire_response_conformance
+    id :dtr_full_ehr_qr_conformance
     title 'QuestionnaireResponse is conformant'
+    description %(
+      Verify that the provided QuestionnaireResponse is conformant to the [DTR
+      QuestionnaireResponse](https://hl7.org/fhir/us/davinci-dtr/STU2/StructureDefinition-dtr-questionnaireresponse.html)
+      profile.
+    )
 
     def profile_url
       config.options[:qr_profile_url]

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_questionnaire_response_correctness_test.rb

@@ -4,34 +4,23 @@ module DaVinciDTRTestKit
   class DTRFullEHRQuestionnaireResponseCorrectnessTest < Inferno::Test
     include DTRQuestionnaireResponseValidation
 
-    id :dtr_full_ehr_questionnaire_response_correctness
+    id :dtr_full_ehr_qr_correctness
     title 'QuestionnaireResponse is correct for the workflow'
     description %(
-      The QuestionnaireResponse aligns with the following expectations for the workflow. This includes checks for
-      the presence of the following answers and their appropriate origin source extensions:
-
-      - `PBD.1` (Last Name) and `LOC.1` (Location): `auto`
-      - PBD.2 (First Name): `override`
-      - `3` (all nested dinner questions): `manual`
+      Verify that the QuestionnaireResponse meets the expected workflow requirements by verifying the following:
+      This includes:
+        - **Completion Check**: Confirm that all required questions have been answered.
+        - **Origin Source Validation**: Verify that specific answers are derived from the correct sources:
+          - `PBD.1` (Last Name) and `LOC.1` (Location): `auto`
+          - `PBD.2` (First Name): `override`
+          - `3` (all nested dinner questions): `manual`
     )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@209', 'hl7.fhir.us.davinci-dtr_2.0.1@210'
 
     run do
-      skip_if questionnaire_response.nil?, 'Completed QuestionnaireResponse input was blank'
-      check_is_questionnaire_response(questionnaire_response)
+      skip_if questionnaire_response.blank?, 'Completed QuestionnaireResponse input was blank'
 
-      qr = FHIR.from_contents(questionnaire_response)
-      questionnaire = if config.options[:adaptive]
-                        qr.contained.find do |res|
-                          res.resourceType == 'Questionnaire'
-                        end
-                      else
-                        Fixtures.questionnaire_for_test(id)
-                      end
-      # questionnaire = Fixtures.find_questionnaire('DinnerOrderStatic')
-      check_origin_sources(questionnaire.item, qr.item, expected_overrides: ['PBD.2'])
-      required_link_ids = extract_required_link_ids(questionnaire.item)
-      check_answer_presence(qr.item, required_link_ids)
-      assert(messages.none? { |m| m[:type] == 'error' }, 'QuestionnaireResponse is not correct, see error message(s)')
+      validate_questionnaire_response_correctness(questionnaire_response, try(:custom_questionnaire_package_response))
     end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_saving_questionnaire_response_group.rb

@@ -4,7 +4,7 @@ require_relative 'dtr_full_ehr_questionnaire_response_correctness_test'
 
 module DaVinciDTRTestKit
   class DTRFullEHRSavingQuestionnaireResponseGroup < Inferno::TestGroup
-    id :dtr_full_ehr_saving_questionnaire_response
+    id :dtr_full_ehr_saving_qr
     title 'Saving the QuestionnaireResponse'
     description %(
         The tester will attest to the completion of the questionnaire such that
@@ -20,10 +20,10 @@ module DaVinciDTRTestKit
     run_as_group
 
     # Test 1: attest QuestionnaireResponse saved
-    test from: :dtr_full_ehr_store_attestation
+    test from: :dtr_full_ehr_store_attest
     # Test 2: verify basic conformance of the QuestionnaireResponse
-    test from: :dtr_full_ehr_questionnaire_response_conformance
+    test from: :dtr_full_ehr_qr_conformance
     # Test 3: check workflow-specific details such as pre-population and overrides
-    test from: :dtr_full_ehr_questionnaire_response_correctness
+    test from: :dtr_full_ehr_qr_correctness
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/full_ehr/dtr_full_ehr_store_attestation_test.rb

@@ -5,12 +5,13 @@ module DaVinciDTRTestKit
   class DTRFullEHRStoreAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_full_ehr_store_attestation
+    id :dtr_full_ehr_store_attest
     title 'Complete and Store the QuestionnaireResponse (Attestation)'
     description %(
       Attest that the questionnaire has been completed and the response has been persisted
       and can be exported as a FHIR QuestionnaireResponse instance.
     )
+
     run do
       random_id = SecureRandom.uuid
       wait(

data/lib/davinci_dtr_test_kit/client_groups/light_ehr/dtr_light_ehr_supported_endpoints_group.rb

@@ -0,0 +1,22 @@
+require_relative 'dtr_light_ehr_supported_payers_config_test'
+require_relative 'dtr_light_ehr_supported_payers_accept_header_test'
+require_relative 'dtr_light_ehr_supported_payers_endpoint_test'
+require_relative 'dtr_light_ehr_supported_payers_user_response_test'
+require_relative 'dtr_light_ehr_supported_payers_use_test'
+
+module DaVinciDTRTestKit
+  class DTRLightEHRSupportedEndpointsGroup < Inferno::TestGroup
+    id :dtr_light_ehr_supported_endpoints
+    title 'Supported Payers Endpoint'
+    description %(This group checks that systems can request and react to a DTR
+      SMART App's [list of supported payers](https://hl7.org/fhir/us/davinci-dtr/STU2/specification.html#determination-of-payers-supported-by-a-dtr-app).
+    )
+    run_as_group
+
+    test from: :dtr_light_ehr_sp_config
+    test from: :dtr_light_ehr_sp_endpoint
+    test from: :dtr_light_ehr_sp_accept_header
+    test from: :dtr_light_ehr_sp_user_response
+    test from: :dtr_light_ehr_sp_use
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/light_ehr/dtr_light_ehr_supported_payers_accept_header_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../urls'
+require_relative '../../tags'
+
+module DaVinciDTRTestKit
+  class DTRLightEHRSupportedPayersAcceptHeaderTest < Inferno::Test
+    include URLs
+    id :dtr_light_ehr_sp_accept_header
+    title 'Client uses the required Accept HTTP header value'
+    description %(
+      This test verifies that the request to the supported payers endpoint
+      includes an `Accept` HTTP header set to `application/json`.
+    )
+
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@108'
+
+    run do
+      load_tagged_requests(SUPPORTED_PAYER_TAG)
+      accept_header = request.request_headers.find { |header| header.name.downcase == 'accept' }
+
+      assert accept_header.present?, 'Accept header must be provided'
+      assert accept_header.value == 'application/json', "Invalid Accept header: Expected 'application/json'
+                                      but received '#{accept_header.value}'"
+      pass 'Accept header is correctly set to application/json'
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/light_ehr/dtr_light_ehr_supported_payers_config_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRLightEHRSupportedPayersConfigTest < Inferno::Test
+    include URLs
+    id :dtr_light_ehr_sp_config
+    title 'Demonstrate supported payers configuration'
+    description %(
+      During this test, the tester will demonstrate the capability of the light EHR under test to configure a supported
+      payers endpoint for Inferno's simulated DTR SMART App.
+    )
+
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@105'
+
+    input :unique_url_id, type: :text
+
+    run do
+      identifier = SecureRandom.hex(32)
+      wait(
+        identifier:,
+        message: <<~MESSAGE
+          Show that the Light EHR under test has been configured to use the following URL
+          as the supported payers endpoint for Inferno's simulated DTR SMART App:
+
+          `#{supported_payer_url(unique_url_id)}`
+
+          [Click here](#{resume_pass_url}?token=#{identifier}) if the system **successfully** demonstrates this configuration.
+
+          [Click here](#{resume_fail_url}?token=#{identifier}) if the system **does not** demonstrate this configuration.
+        MESSAGE
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/light_ehr/dtr_light_ehr_supported_payers_endpoint_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRLightEHRSupportedPayersEndpointTest < Inferno::Test
+    include URLs
+    id :dtr_light_ehr_sp_endpoint
+    title 'Client can request an app\'s supported payers list'
+    description %(
+      This test verifies that the app can successfully access the supported payers endpoint via a GET request
+    )
+    input :unique_url_id,
+          title: 'Supported Payers Endpoint Path',
+          description: %(
+            A unique identifier that will be used to construct the supported payers
+            endpoint URL. This allows a permanent configuration for the tester to
+            use across Inferno sessions.
+          )
+    input :user_response,
+          title: 'Custom Supported Payers Response',
+          description: %(
+            If present, the value will be returned when the client makes a request to the supported payers endpoint,
+            allowing testers to instruct Inferno how to respond with payers that are configured in the
+            system under test. The provided response will be checked for conformance to the required
+            JSON structure. If not provided, Inferno will return a pre-configured value.
+          ),
+          optional: true,
+          type: 'textarea'
+
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@104', 'hl7.fhir.us.davinci-dtr_2.0.1@107'
+
+    run do
+      wait(
+        identifier: unique_url_id,
+        message: %(
+          ### Supported Payer Endpoint
+
+          Inferno will wait for the Light EHR to to make a GET request to
+
+          `#{supported_payer_url(unique_url_id)}`
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/light_ehr/dtr_light_ehr_supported_payers_use_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../urls'
+
+module DaVinciDTRTestKit
+  class DTRLightEHRSupportedPayersUseTest < Inferno::Test
+    include URLs
+    id :dtr_light_ehr_sp_use
+    title 'Demonstrate use of the supported payers response'
+    description %(
+      During this test, the tester will demonstrate the ability of the light EHR under test to use the response from
+      the supported payers endpoint to suppress the launch of Inferno's simulated DTR SMART App for a patient
+      who is covered only by payers not included in the returned supported payers list.
+    )
+
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@115'
+
+    run do
+      identifier = SecureRandom.hex(32)
+      wait(
+        identifier:,
+        message: <<~MESSAGE
+          Demonstrate that when DTR is needed for a patient that is not covered by payers included in the
+          supported payers list returned from the endpoint, launching Inferno's simulated DTR App
+          is not an option.
+
+          [Click here](#{resume_pass_url}?token=#{identifier}) if the system **successfully** demonstrates this capability.
+
+          [Click here](#{resume_fail_url}?token=#{identifier}) if the system **does not** demonstrate this capability.
+        MESSAGE
+      )
+    end
+  end
+end