davinci_dtr_test_kit 0.14.2 → 0.15.0

data/lib/davinci_dtr_test_kit/dtr_smart_app_suite.rb

@@ -1,7 +1,8 @@
 require_relative 'auth_groups/oauth2_authentication_group'
-require_relative 'client_groups/resp_assist_device/dtr_smart_app_questionnaire_workflow_group'
-require_relative 'client_groups/dinner_static/dtr_smart_app_questionnaire_workflow_group'
-require_relative 'client_groups/dinner_adaptive/dtr_smart_app_questionnaire_workflow_group'
+require_relative 'client_groups/respiratory/dtr_smart_app_respiratory_workflow_group'
+require_relative 'client_groups/dinner_static/dtr_smart_app_static_dinner_workflow_group'
+require_relative 'client_groups/dinner_adaptive/dtr_smart_app_adaptive_dinner_workflow_group'
+require_relative 'client_groups/custom_static/dtr_smart_app_custom_static_workflow_group'
 require_relative 'endpoints/cors'
 require_relative 'endpoints/mock_authorization'
 require_relative 'endpoints/mock_authorization/authorize_endpoint'
@@ -21,8 +22,6 @@ module DaVinciDTRTestKit
     title 'Da Vinci DTR SMART App Test Suite'
     description File.read(File.join(__dir__, 'docs', 'dtr_smart_app_suite_description_v201.md'))
 
-    version VERSION
-
     links [
       {
         label: 'Report Issue',
@@ -67,7 +66,7 @@ module DaVinciDTRTestKit
     suite_endpoint :post, NEXT_PATH, MockPayer::NextQuestionEndpoint
 
     # EHR
-    route(:get, '/fhir/metadata', MockEHR.method(:metadata))
+    route(:get, METADATA_PATH, MockEHR.method(:metadata))
     suite_endpoint :post, QUESTIONNAIRE_RESPONSE_PATH, MockEHR::QuestionnaireResponseEndpoint
     suite_endpoint :get, FHIR_RESOURCE_PATH, MockEHR::FHIRGetEndpoint
     suite_endpoint :get, FHIR_SEARCH_PATH, MockEHR::FHIRGetEndpoint
@@ -90,8 +89,8 @@ module DaVinciDTRTestKit
         Tests in this group validate that the client can complete basic DTR workflows
       )
 
-      group from: :dtr_smart_app_static_dinner_questionnaire_workflow
-      group from: :dtr_smart_app_adaptive_dinner_questionnaire_workflow
+      group from: :dtr_smart_app_custom_static_workflow
+      group from: :dtr_smart_app_adaptive_dinner_workflow
     end
     group do
       id :dtr_smart_app_questionnaire_functionality
@@ -100,7 +99,8 @@ module DaVinciDTRTestKit
         Tests in this group validate that the client can complete additional DTR workflows
         covering additional must support features of questionnaires.
       )
-      group from: :dtr_smart_app_questionnaire_workflow
+      group from: :dtr_smart_app_resp_workflow
+      group from: :dtr_smart_app_static_dinner_workflow
     end
   end
 end

data/lib/davinci_dtr_test_kit/endpoints/mock_authorization.rb

@@ -62,8 +62,8 @@ module DaVinciDTRTestKit
       base_url = env_base_url(env, OPENID_CONFIG_PATH)
       response_body = {
         issuer: base_url + FHIR_BASE_PATH,
-        authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
-        token_endpoint: base_url + EHR_TOKEN_PATH,
+        authorization_endpoint: authorization_endpoint(base_url),
+        token_endpoint: token_endpoint(base_url),
         jwks_uri: base_url + JKWS_PATH,
         response_types_supported: ['id_token'],
         subject_types_supported: ['public'],
@@ -79,5 +79,13 @@ module DaVinciDTRTestKit
       path.gsub!(%r{#{endpoint_path}(/)?}, '')
       "#{protocol}://#{host + path}"
     end
+
+    def authorization_endpoint(base_url)
+      base_url + EHR_AUTHORIZE_PATH
+    end
+
+    def token_endpoint(base_url)
+      base_url + EHR_TOKEN_PATH
+    end
   end
 end

data/lib/davinci_dtr_test_kit/endpoints/mock_ehr.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../endpoints/mock_authorization'
+
 module DaVinciDTRTestKit
   module MockEHR
     RESOURCE_SERVER_BASE = ENV.fetch('FHIR_REFERENCE_SERVER')
@@ -13,9 +15,23 @@ module DaVinciDTRTestKit
       client
     end
 
-    def metadata(_env)
+    def metadata(env)
       cs = resource_server_client.capability_statement
       if cs.present?
+        # Overwrite the OAuth URIs returned by the reference server to point to the suite endpoints instead
+        oauth_uris_url = 'http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris'
+        base_url = MockAuthorization.env_base_url(env, METADATA_PATH)
+        sec_ext = cs.rest.first&.security&.extension&.delete_if { |e| e.url == oauth_uris_url }
+        sec_ext&.push(
+          FHIR::Extension.new(
+            url: oauth_uris_url,
+            extension: [
+              FHIR::Extension.new(url: 'authorize', valueUri: MockAuthorization.authorization_endpoint(base_url)),
+              FHIR::Extension.new(url: 'token', valueUri: MockAuthorization.token_endpoint(base_url))
+            ]
+          )
+        )
+
         [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']]

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

@@ -19,7 +19,13 @@ module DaVinciDTRTestKit
         response.status = 200
         response.format = 'application/fhir+json'
         response.headers['Access-Control-Allow-Origin'] = '*'
-        response.body = build_questionnaire_package_response.to_json
+        response.body = custom_response.presence || build_questionnaire_package_response.to_json
+      end
+
+      def custom_response
+        @custom_response ||= JSON.parse(result.input_json)
+          .find { |input| input['name'].include?('custom_questionnaire_package_response') }
+          &.dig('value')
       end
 
       def update_result

data/lib/davinci_dtr_test_kit/fixtures.rb

@@ -8,7 +8,7 @@ module DaVinciDTRTestKit
     FIXTURE_CONFIG = [
       {
         group_ids: [
-          'dtr_smart_app_questionnaire_workflow',
+          'dtr_smart_app_resp_workflow',
           'dtr_full_ehr_questionnaire_workflow'
         ],
         questionnaire_package: File.join('respiratory_assist_device', 'questionnaire_package.json'),
@@ -16,23 +16,23 @@ module DaVinciDTRTestKit
       },
       {
         group_ids: [
-          'dtr_smart_app_static_dinner_questionnaire_workflow',
-          'dtr_full_ehr_static_dinner_questionnaire_workflow'
+          'dtr_smart_app_static_dinner_workflow',
+          'dtr_full_ehr_static_dinner_workflow'
         ],
         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'
+          'dtr_full_ehr_adaptive_retrieval',
+          'dtr_smart_app_adaptive_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'
+          'dtr_adaptive_followup_questions'
         ],
         next_question: {
           bean_burrito: File.join('dinner_adaptive', 'dinner_order_adaptive_next_question_burrito.json'),

data/lib/davinci_dtr_test_kit/metadata.rb

@@ -0,0 +1,104 @@
+require_relative 'version'
+
+module DaVinciDTRTestKit
+  class Metadata < Inferno::TestKit
+    id :davinci_dtr_test_kit
+    title 'DDa Vinci Documentation Templates and Rules (DTR) Test Kit'
+    description <<~DESCRIPTION
+      The Da Vinci Documentation Templates and Rules (DTR) Test Kit validates
+      the conformance of DTR SMART app client and payer server implementations to
+      [version 2.0.1 of the Da Vinci DTR Implementation
+      Guide](https://hl7.org/fhir/us/davinci-dtr/STU2/).
+
+      <!-- break -->
+
+      ## Status
+
+      These tests are a **DRAFT** intended to allow DTR implementers to perform
+      preliminary checks of their implementations against the DTR IG requirements and
+      provide feedback on the tests. Future versions of these tests may validate other
+      requirements and may change how these are tested.
+
+      ## Test Scope and Limitations
+
+      The DTR Test Kit includes suites for the following DTR actors:
+      - **DTR Payer Server**: verifies the ability of a payer server to respond
+        to requests for questionnaires.
+      - **DTR SMART App**: verifies the ability of a SMART app to launch, get questionnaires
+        from a payer server, render them, and allow users to complete them.
+      - **Full DTR EHR**: verifies the ability of a EHR to get questionnaires
+        from a payer server, render them, and allow users to complete them.
+      - **Light DTR EHR**: verifies the ability of a EHR to launch a DTR SMART
+        app and respond to FHIR data gathering requests.
+
+      Documentation of the current tests and their limitations can be found in each
+      suite's description when the tests are run and can also be viewed in the
+      source code:
+      - [SMART App Test Suite Limitations](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/lib/davinci_dtr_test_kit/docs/dtr_smart_app_suite_description_v201.md)
+      - [Payer Server Test Suite Limitations](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/lib/davinci_dtr_test_kit/docs/dtr_payer_server_suite_description_v201.md)
+      - [Full DTR EHR Test Suite Limitations](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/lib/davinci_dtr_test_kit/docs/dtr_full_ehr_suite_description_v201.md)
+      - [Light DTR EHR Test Suite Limitations](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/lib/davinci_dtr_test_kit/docs/dtr_light_ehr_suite_description_v201.md)
+
+      ### Test Scope
+
+      To validate the behavior of the system under test, Inferno will act as an
+      exchange partner. Specifically,
+
+      - **When testing a DTR SMART app client**: Inferno will simulate both a payer
+        server that can return questionnaires and a Light DTR EHR that can respond
+        to queries for clinical data used to pre-populate questionnaire responses.
+        Inferno uses the SMART App Launch framework to establish a connection with
+        the app under test, either in EHR Launch or Standalone Launch mode. The app
+        will be expected to initiate requests to Inferno and demonstrate its ability
+        to react to the returned responses. Over the course of these interactions,
+        Inferno will seek to observe the conformant completion of a questionnaire
+        including pre-population, as well as the ability of the app to correctly
+        render the questionnaire and allow users to interact with it.
+      - **When testing a DTR payer server**: Inferno will simulate a DTR app
+        by requesting questionnaires from the server under test. The server
+        will be expected to respond to these requests from Inferno. Over the course
+        of these interactions, Inferno will seek to observe the ability of the
+        server under test to return conformant questionnaires.
+      - **When testing a Full DTR EHR client**: Inferno will simulate a payer
+        server that can return questionnaires. The EHR will be expected to initiate
+        requests to Inferno and demonstrate its ability to react to the returned
+        responses. Over the course of these interactions,
+        Inferno will seek to observe the conformant completion of a questionnaire
+        including fetch, as well as the ability of the app to correctly
+        render the questionnaire and allow users to interact with it.
+      - **When testing a Light DTR EHR server**: Inferno will simulate a DTR SMART app
+        that tested servers can launch and that will request FHIR data from and create
+        and update QuestionnaireResponse and Task instances on the server under test.
+        Over the course of these interactions, Inferno will seek to observe the ability of the
+        server under test to conformantly serve as a FHIR server for a DTR SMART App.
+
+      ### Known Limitations
+
+      - **SMART app tests**:
+        - Some questionnaire features, including adaptive questionnaires, are not yet tested.
+        - Inferno uses a single FHIR endpoint to simulate both the payer and the EHR.
+      - **Payer server tests**:
+        - Inferno checks that CQL is used for pre-population in the questionnaires returned by the
+          payer server, but does not currently validate the correctness or executability of that CQL.
+      - **Full EHR tests**:
+        - Some questionnaire features are not yet tested.
+        - Non-standard approach to accessing QuestionnaireResponse instances for validation.
+      - **Light EHR tests**:
+        - `fhirContext` not tested as a part of the Light EHR's SMART App launch process.
+
+      ## Reporting Issues
+
+      Please report any issues with this set of tests in the [GitHub
+      Issues](https://github.com/inferno-framework/davinci-dtr-test-kit/issues)
+      section of the
+      [open-source code repository](https://github.com/inferno-framework/davinci-dtr-test-kit).
+    DESCRIPTION
+    suite_ids [:dtr_payer_server, :dtr_smart_app, :dtr_full_ehr, :dtr_light_ehr]
+    tags ['Da Vinci', 'DTR']
+    last_updated LAST_UPDATED
+    version VERSION
+    maturity 'Low'
+    authors ['Karl Naden', 'Tom Strassner', 'Robert Passas', 'Vanessa Fotso', 'Elsa Perelli']
+    repo 'https://github.com/inferno-framework/davinci-dtr-test-kit'
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_libraries_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:adaptive_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       check_libraries(scratch[:adaptive_questionnaire_bundles])
     end
   end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_expressions_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:adaptive_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       questionnaires = extract_questionnaires_from_bundles(scratch[:adaptive_questionnaire_bundles])
       verify_questionnaire_items(questionnaires)
       scratch[:adaptive_questionnaire_bundles] = nil

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_form_questionnaire_extensions_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      skip_if scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:adaptive_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       questionnaires = extract_questionnaires_from_bundles(scratch[:adaptive_questionnaire_bundles])
       verify_questionnaire_extensions(questionnaires)
     end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_bundles_validation_test.rb

@@ -22,7 +22,7 @@ module DaVinciDTRTestKit
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
       test_passed = true
       profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1'
-      assert !scratch[:adaptive_questionnaire_bundles].nil?, 'No resources to validate.'
+      assert scratch[:adaptive_questionnaire_bundles].present?, 'No resources to validate.'
       scratch[:adaptive_questionnaire_bundles].each_with_index do |bundle, index|
         resource_is_valid = validate_resource(bundle, :bundle, profile_url, index)
         test_passed = false unless resource_is_valid

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_search_validation_test.rb

@@ -22,7 +22,7 @@ module DaVinciDTRTestKit
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
       test_passed = true
       profile_url = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaire-adapt-search|2.0.1'
-      assert !scratch[:adaptive_questionnaire_bundles].nil?, 'No questionnaire bundles to validate.'
+      assert scratch[:adaptive_questionnaire_bundles].present?, 'No questionnaire bundles to validate.'
 
       questionnaires = scratch[:adaptive_questionnaire_bundles].filter_map do |bundle|
         bundle.entry&.filter_map { |entry| entry.resource if entry.resource&.resourceType == 'Questionnaire' }

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_validation_test.rb

@@ -1,7 +1,9 @@
 require_relative '../validation_test'
+require_relative '../cql_test'
 module DaVinciDTRTestKit
   class PayerAdaptiveFormQuestionnaireResponseTest < Inferno::Test
     include DaVinciDTRTestKit::ValidationTest
+    include DaVinciDTRTestKit::CQLTest
     id :payer_server_adaptive_response_validation_test
     title 'Validate that the adaptive response conforms to the DTR Questionnaire Package operation definition'
     # output :questionnaire_response
@@ -38,21 +40,8 @@ module DaVinciDTRTestKit
       assert_response_status([200, 201], response: req.response)
 
       resource = FHIR.from_contents(req.response_body)
-      if resource&.resourceType == 'Parameters'
-        scratch[:adaptive_questionnaire_bundles] = resource.parameter.filter_map do |param|
-          param.resource if param.resource&.resourceType == 'Bundle'
-        end
-        assert_valid_resource(resource:,
-                              profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1')
-        questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
-        assert questionnaire_bundle, 'No questionnaire bundle found in the response'
-      elsif resource&.resourceType == 'Bundle'
-        scratch[:adaptive_questionnaire_bundles] = [resource]
-        assert_valid_resource(resource:,
-                              profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')
-      else
-        assert(false, "Unexpected resourceType: #{resource&.resourceType}. Expected Parameters or Bundle")
-      end
+
+      perform_questionnaire_package_validation(resource, 'adaptive')
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_static_group.rb

@@ -43,7 +43,7 @@ module DaVinciDTRTestKit
                 :access_token,
                 :initial_static_questionnaire_request
 
-    test from: :dtr_v201_payer_static_questionnaire_request_test, receives_request: :static_questionnaire_request
+    test from: :dtr_v201_payer_static_request_test, receives_request: :static_questionnaire_request
     test from: :dtr_v201_payer_static_form_request_validation_test
     test from: :dtr_v201_payer_static_form_response_test
     test from: :dtr_v201_payer_static_form_libraries_test

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_libraries_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:static_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:static_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       check_libraries(scratch[:static_questionnaire_bundles])
     end
   end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_expressions_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:static_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:static_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       questionnaires = extract_questionnaires_from_bundles(scratch[:static_questionnaire_bundles])
       verify_questionnaire_items(questionnaires, final_cql_test: true)
       scratch[:static_questionnaire_bundles] = nil

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_extensions_test.rb

@@ -12,7 +12,7 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:static_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      skip_if scratch[:static_questionnaire_bundles].blank?, 'No questionnaire bundle returned.'
       questionnaires = extract_questionnaires_from_bundles(scratch[:static_questionnaire_bundles])
       verify_questionnaire_extensions(questionnaires)
     end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_request_test.rb

@@ -7,7 +7,7 @@ module DaVinciDTRTestKit
     description %(
       Inferno will validate questionnaires returned by the payer server.
     )
-    id :dtr_v201_payer_static_questionnaire_request_test
+    id :dtr_v201_payer_static_request_test
     config options: { accepts_multiple_requests: false }
     input :initial_static_questionnaire_request, :access_token, :retrieval_method, :url
 

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_response_validation_test.rb

@@ -1,9 +1,11 @@
 require_relative '../urls'
 require_relative '../validation_test'
+require_relative '../cql_test'
 module DaVinciDTRTestKit
   class PayerStaticFormResponseTest < Inferno::Test
     include URLs
     include DaVinciDTRTestKit::ValidationTest
+    include DaVinciDTRTestKit::CQLTest
     id :dtr_v201_payer_static_form_response_test
     title 'Validate that the static response conforms to the DTR Questionnaire Package operation definition.'
     description %(
@@ -36,21 +38,8 @@ module DaVinciDTRTestKit
       assert_response_status([200, 201], response: req.response)
 
       resource = FHIR.from_contents(req.response_body)
-      if resource&.resourceType == 'Parameters'
-        scratch[:static_questionnaire_bundles] = resource.parameter&.filter_map do |param|
-          param.resource if param.resource&.resourceType == 'Bundle'
-        end
-        assert_valid_resource(resource:,
-                              profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1')
-        questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
-        assert questionnaire_bundle, 'No questionnaire bundle found in the response'
-      elsif resource&.resourceType == 'Bundle'
-        scratch[:static_questionnaire_bundles] = [resource]
-        assert_valid_resource(resource:,
-                              profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')
-      else
-        assert(false, "Unexpected resourceType: #{resource&.resourceType}. Expected Parameters or Bundle")
-      end
+
+      perform_questionnaire_package_validation(resource, 'static')
     end
   end
 end

data/lib/davinci_dtr_test_kit/profiles/communication_request/communication_request_must_support_test.rb

@@ -0,0 +1,46 @@
+module DaVinciDTRTestKit
+  class CommunicationRequestMustSupportTest < Inferno::Test
+    include USCoreTestKit::MustSupportTest
+
+    title 'All must support elements are provided in the CommunicationRequest resources returned'
+    description %(
+      This test will look through the CommunicationRequest resources
+      found previously for the following must support elements:\n
+
+      * CommunicationRequest.authoredOn
+      * CommunicationRequest.basedOn
+      * CommunicationRequest.extension:Coverage-Information
+      * CommunicationRequest.identifier
+      * CommunicationRequest.occurrence[x]
+      * CommunicationRequest.payload
+      * CommunicationRequest.payload.extension:codeableConcept
+      * CommunicationRequest.reasonCode
+      * CommunicationRequest.reasonReference
+      * CommunicationRequest.recipient
+      * CommunicationRequest.requester
+      * CommunicationRequest.sender
+      * CommunicationRequest.status
+      * CommunicationRequest.subject
+    )
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@355'
+    id :communication_request_must_support_test
+
+    def resource_type
+      'CommunicationRequest'
+    end
+
+    def self.metadata
+      @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'),
+                                                                               aliases: true))
+    end
+
+    def scratch_resources
+      scratch[:communication_requests] ||= {}
+    end
+
+    run do
+      skip_if(communication_request_ids.nil?, "No `#{resource_type}` IDs provided, skipping test.")
+      perform_must_support_test(all_scratch_resources)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/communication_request/communication_request_read.rb

@@ -6,6 +6,7 @@ module DaVinciDTRTestKit
 
     title 'Server returns correct CommunicationRequest resource from CommunicationRequest read interaction'
     description 'A server SHOULD support the CommunicationRequest read interaction.'
+    verifies_requirements 'hl7.fhir.us.davinci-dtr_2.0.1@275'
 
     id :communication_request_read
     output :communication_request_resources
@@ -14,6 +15,10 @@ module DaVinciDTRTestKit
       'CommunicationRequest'
     end
 
+    def scratch_resources
+      scratch[:communication_requests] ||= {}
+    end
+
     def communication_request_id_list
       return [nil] unless respond_to? :communication_request_ids
 
@@ -21,9 +26,7 @@ module DaVinciDTRTestKit
     end
 
     run do
-      resources = perform_read_test(communication_request_id_list, resource_type)
-
-      output communication_request_resources: resources.to_json
+      perform_read_test(communication_request_id_list, resource_type)
     end
   end
 end

data/lib/davinci_dtr_test_kit/profiles/communication_request/communication_request_validation.rb

@@ -1,8 +1,6 @@
-require_relative '../../validation_test'
-
 module DaVinciDTRTestKit
   class CommunicationRequestValidationTest < Inferno::Test
-    include DaVinciDTRTestKit::ValidationTest
+    include USCoreTestKit::ValidationTest
 
     title 'CommunicationRequest resources returned during previous tests conform to the CRD CommunicationRequest'
     description %(
@@ -19,17 +17,20 @@ fail if their code/system are not found in the valueset.
     )
 
     id :communication_request_validation
-    input :communication_request_resources,
-          optional: true
 
     def resource_type
       'CommunicationRequest'
     end
 
+    def scratch_resources
+      scratch[:communication_requests] ||= {}
+    end
+
     run do
-      skip_if(communication_request_ids.nil?, "No `#{resource_type}` IDs provided, skipping test.")
-      perform_profile_validation_test(communication_request_resources, resource_type,
-                                      'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest|2.0.1')
+      perform_validation_test(scratch_resources[:all] || [],
+                              'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest',
+                              '2.0.1',
+                              skip_if_empty: true)
     end
   end
 end