davinci_dtr_test_kit 0.13.0 → 0.14.1

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_extensions_test.rb

@@ -1,10 +1,10 @@
 require_relative '../cql_test'
 module DaVinciDTRTestKit
-  class PayerStaticFormExtensionsTest < Inferno::Test
+  class PayerAdaptiveNexQuestionExtensionsTest < Inferno::Test
     include DaVinciDTRTestKit::CQLTest
 
-    id :dtr_v201_payer_adaptive_next_form_extensions_test
-    title 'Questionnaire(s) contains extensions necessary for pre-population'
+    id :dtr_v201_payer_adaptive_next_question_extensions_test
+    title 'Adaptive Next Question questionnaire(s) contain extensions necessary for pre-population'
     description %(
       Inferno checks that the payer server response has appropriate extensions and references to libraries within
       those extensions.
@@ -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[:next_responses].nil?, 'No questionnaires returned.'
-      questionnaire_extensions_test(scratch[:next_responses])
+      skip_if scratch[:next_question_questionnaire_responses].nil?, 'No questionnaires returned.'
+      questionnaires = extract_contained_questionnaires(scratch[:next_question_questionnaire_responses])
+      verify_questionnaire_extensions(questionnaires)
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_group.rb

@@ -81,8 +81,8 @@ module DaVinciDTRTestKit
 
     # 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: :dtr_v201_payer_adaptive_next_question_extensions_test
+    test from: :dtr_v201_payer_adaptive_next_question_expressions_test
     test from: :payer_server_adaptive_completion_test
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_bundles_validation_test.rb

@@ -22,15 +22,12 @@ 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_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 = false unless resource_is_valid
-        rescue StandardError
-          next
-        end
+      assert !scratch[:adaptive_questionnaire_bundles].nil?, '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
+      rescue StandardError
+        next
       end
       if !test_passed && !tests_failed[profile_url].blank?
         assert test_passed, "Not all returned resources conform to the profile: #{profile_url}"

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_search_validation_test.rb

@@ -3,7 +3,7 @@ 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'
+    title 'Validate that the adaptive response contains a valid 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)
@@ -22,18 +22,21 @@ 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_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 = false unless resource_is_valid
-          end
-        rescue StandardError
-          next
-        end
+      assert !scratch[:adaptive_questionnaire_bundles].nil?, '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' }
+      end&.flatten&.compact
+
+      assert questionnaires&.any?, 'No adaptive questionnaires to validate.'
+
+      questionnaires.each_with_index do |questionnaire, index|
+        resource_is_valid = validate_resource(questionnaire, :questionnaire, profile_url, index)
+        test_passed = false unless resource_is_valid
+      rescue StandardError
+        next
       end
+
       if !test_passed && !tests_failed[profile_url].blank?
         assert test_passed, "Not all returned resources conform to the profile: #{profile_url}"
       end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_validation_test.rb

@@ -3,12 +3,16 @@ module DaVinciDTRTestKit
   class PayerAdaptiveFormQuestionnaireResponseTest < Inferno::Test
     include DaVinciDTRTestKit::ValidationTest
     id :payer_server_adaptive_response_validation_test
-    title 'Validate that the adaptive response conforms to the Output Parameters profile'
+    title 'Validate that the adaptive response conforms to the DTR Questionnaire Package operation definition'
     # output :questionnaire_response
     description %(
-      This test validates the conformance of the payer's response to the
-      [DTR Output Parameters](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters)
-      structure.
+      Inferno will validate that the payer server's response to the questionnaire-package operation is conformant
+      to the
+      [Questionnaire Package operation definition](https://hl7.org/fhir/us/davinci-dtr/STU2/OperationDefinition-questionnaire-package.html).
+      This includes verifying that the response conforms to the
+      [DTR Questionnaire Package Bundle profile](https://hl7.org/fhir/us/davinci-dtr/STU2/StructureDefinition-DTR-QPackageBundle.html)
+      and, in the event that the server includes that Bundle in a Parameters object, the
+      [DTR Questionnaire Package Output Parameters profile](https://hl7.org/fhir/us/davinci-dtr/STU2/StructureDefinition-dtr-qpackage-output-parameters.html).
 
       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
@@ -21,28 +25,34 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      profile_with_version = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1'
       endpoint = custom_endpoint.blank? ? '/Questionnaire/$questionnaire-package' : custom_endpoint
-      if initial_adaptive_questionnaire_request.nil?
-        # making the assumption that only one response was received - if there were multiple, we are only validating the
-        # first
-        response = load_tagged_requests(QUESTIONNAIRE_TAG)[0]
-        scratch[:adaptive_responses] = [response]
-        resource = FHIR.from_contents(response.response[:body])
+      req = if initial_adaptive_questionnaire_request.nil?
+              # making the assumption that only one response was received - if there were multiple, we are only
+              # validating the first
+              load_tagged_requests(QUESTIONNAIRE_TAG)[0]
+            else
+              fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
+                                                  headers: { 'Content-Type': 'application/fhir+json' })
+            end
+      skip_if req.nil?, 'No request resource received from the client.'
+      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
-        response = fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
-                                                       headers: { 'Content-Type': 'application/json' })
-        resource = FHIR.from_contents(response.response[:body])
-        scratch[:adaptive_responses] = [response]
+        assert(false, "Unexpected resourceType: #{resource&.resourceType}. Expected Parameters or Bundle")
       end
-
-      assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
-      assert_response_status([200, 201], response: response.response)
-      assert_resource_type(:parameters, resource:)
-      assert_valid_resource(resource:, profile_url: profile_with_version)
-      questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
-      assert questionnaire_bundle, 'No questionnaire bundle found in the response'
-      assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_response_complete_test.rb

@@ -8,10 +8,10 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      assert !scratch[:next_responses].nil?, 'No resources to validate.'
-      assert scratch[:next_responses].any? { |r|
-               JSON.parse(r.response_body)['status'] == 'completed'
-             }, 'Next request sequence did not result in a completed questionnaire.'
+      assert !scratch[:next_question_questionnaire_responses].nil?, 'No resources to validate.'
+      assert scratch[:next_question_questionnaire_responses].any? { |qr| qr.status == 'completed' },
+             'Next request sequence did not result in a completed questionnaire.'
+      scratch[:next_question_questionnaire_responses] = nil
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_response_validation_test.rb

@@ -20,20 +20,24 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
-      if next_question_requests.nil?
-        resources = load_tagged_requests(NEXT_TAG)
-      else
-        json_requests = JSON.parse(next_question_requests)
-        resources = json_requests.map do |resource|
-          fhir_operation("#{url}/Questionnaire/$next-question",
-                         body: resource,
-                         headers: { 'Content-Type': 'application/json' })
-        end
+      reqs = if next_question_requests.nil?
+               load_tagged_requests(NEXT_TAG)
+             else
+               json_requests = JSON.parse(next_question_requests)
+               json_requests.map do |resource|
+                 fhir_operation("#{url}/Questionnaire/$next-question",
+                                body: resource,
+                                headers: { 'Content-Type': 'application/fhir+json' })
+               end
+             end
+      assert !reqs.nil?, 'No requests to validate.'
+      scratch[:next_question_questionnaire_responses] = reqs.map do |req|
+        assert_response_status([200, 202], request: req)
+        FHIR.from_contents(req.response_body)
       end
-      assert !resources.nil?, 'No resources to validate.'
-      scratch[:next_responses] = resources
+
       perform_response_validation_test(
-        resources,
+        scratch[:next_question_questionnaire_responses],
         :questionnaireResponse,
         'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse'
       )

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_libraries_test.rb

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

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_expressions_test.rb

@@ -4,7 +4,7 @@ module DaVinciDTRTestKit
     include DaVinciDTRTestKit::CQLTest
 
     id :dtr_v201_payer_static_form_expressions_test
-    title 'Questionnaire(s) contains items with expressions necessary for pre-population'
+    title 'Static questionnaire(s) contain 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.
@@ -12,9 +12,10 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:output_parameters].nil?, 'No questionnaire bundle returned.'
-      questionnaire_items_test(scratch[:output_parameters], final_cql_test: true)
-      scratch[:output_parameters] = nil
+      skip_if scratch[:static_questionnaire_bundles].nil?, '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
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_extensions_test.rb

@@ -4,7 +4,7 @@ module DaVinciDTRTestKit
     include DaVinciDTRTestKit::CQLTest
 
     id :dtr_v201_payer_static_form_extensions_test
-    title 'Questionnaire(s) contains extensions necessary for pre-population'
+    title 'Static questionnaire(s) contain extensions necessary for pre-population'
     description %(
       Inferno checks that the payer server response has appropriate extensions and references to libraries within
       those extensions.
@@ -12,8 +12,9 @@ module DaVinciDTRTestKit
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      skip_if scratch[:output_parameters].nil?, 'No questionnaire bundle returned.'
-      questionnaire_extensions_test(scratch[:output_parameters])
+      skip_if scratch[:static_questionnaire_bundles].nil?, 'No questionnaire bundle returned.'
+      questionnaires = extract_questionnaires_from_bundles(scratch[:static_questionnaire_bundles])
+      verify_questionnaire_extensions(questionnaires)
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_response_validation_test.rb

@@ -5,44 +5,51 @@ module DaVinciDTRTestKit
     include URLs
     include DaVinciDTRTestKit::ValidationTest
     id :dtr_v201_payer_static_form_response_test
-    title 'Validate that the static response conforms to the Output Parameters profile'
+    title 'Validate that the static response conforms to the DTR Questionnaire Package operation definition.'
     description %(
-      Inferno will validate that the payer server response conforms to the
-       [Output Parameters profile](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters).
+      Inferno will validate that the payer server's response to the questionnaire-package operation is conformant
+      to the
+      [Questionnaire Package operation definition](https://hl7.org/fhir/us/davinci-dtr/STU2/OperationDefinition-questionnaire-package.html).
+      This includes verifying that the response conforms to the
+      [DTR Questionnaire Package Bundle profile](https://hl7.org/fhir/us/davinci-dtr/STU2/StructureDefinition-DTR-QPackageBundle.html)
+      and, in the event that the server includes that Bundle in a Parameters object, the
+      [DTR Questionnaire Package Output Parameters profile](https://hl7.org/fhir/us/davinci-dtr/STU2/StructureDefinition-dtr-qpackage-output-parameters.html).
 
       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.
-
     )
     input :url
 
     run do
       skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
-      profile_with_version = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1'
-      if initial_static_questionnaire_request.nil?
-        skip_if access_token.nil?, 'No access token provided - required for client flow.'
-        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
-        skip_if resources.nil?, 'No request resource received from the client.'
-        scratch[:output_parameters] = resources
-        # making the assumption that only one response was received- if there were multiple, we are only validating the
-        # first
-        assert_valid_resource(resource: FHIR.from_contents(resources[0].request[:body]),
-                              profile_url: profile_with_version)
-      else
-        request = fhir_operation("#{url}/Questionnaire/$questionnaire-package",
-                                 body: JSON.parse(initial_static_questionnaire_request),
-                                 headers: { 'Content-Type': 'application/json' })
-        assert_valid_json(request.response[:body])
-        resource = FHIR.from_contents(request.response[:body])
-        scratch[:output_parameters] = resource
-        assert_response_status([200, 201], response: request.response)
-        assert_resource_type(:parameters, resource:)
-        assert_valid_resource(resource:, profile_url: profile_with_version)
+      req = if initial_static_questionnaire_request.nil?
+              load_tagged_requests(QUESTIONNAIRE_TAG)
+            else
+              fhir_operation("#{url}/Questionnaire/$questionnaire-package",
+                             body: JSON.parse(initial_static_questionnaire_request),
+                             headers: { 'Content-Type': 'application/fhir+json' })
+            end
+
+      skip_if req.nil?, 'No request resource received from the client.'
+      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'
-        assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')
+      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
     end
   end

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

@@ -0,0 +1,29 @@
+require_relative '../../read_test'
+
+module DaVinciDTRTestKit
+  class CommunicationRequestReadTest < Inferno::Test
+    include DaVinciDTRTestKit::ReadTest
+
+    title 'Server returns correct CommunicationRequest resource from CommunicationRequest read interaction'
+    description 'A server SHOULD support the CommunicationRequest read interaction.'
+
+    id :communication_request_read
+    output :communication_request_resources
+
+    def resource_type
+      'CommunicationRequest'
+    end
+
+    def communication_request_id_list
+      return [nil] unless respond_to? :communication_request_ids
+
+      communication_request_ids&.split(',')&.map(&:strip)
+    end
+
+    run do
+      resources = perform_read_test(communication_request_id_list, resource_type)
+
+      output communication_request_resources: resources.to_json
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative '../../validation_test'
+
+module DaVinciDTRTestKit
+  class CommunicationRequestValidationTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+
+    title 'CommunicationRequest resources returned during previous tests conform to the CRD CommunicationRequest'
+    description %(
+This test verifies resources returned from the read step conform to
+the [CRD CommunicationRequest](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-communicationrequest).
+Systems must demonstrate at least one valid example in order to pass this test.
+
+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.
+
+    )
+
+    id :communication_request_validation
+    input :communication_request_resources,
+          optional: true
+
+    def resource_type
+      'CommunicationRequest'
+    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')
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/communication_request_group.rb

@@ -0,0 +1,39 @@
+require_relative 'communication_request/communication_request_read'
+require_relative 'communication_request/communication_request_validation'
+
+module DaVinciDTRTestKit
+  class CommunicationRequestGroup < Inferno::TestGroup
+    title 'CRD CommunicationRequest Tests'
+    short_description 'Verify support for the server capabilities required by the CRD CommunicationRequest Profile'
+    description %(
+      # Background
+
+    The CRD CommunicationRequest sequence verifies that the system under test is
+    able to provide correct responses for CommunicationRequest queries. These queries
+    must return resources conforming to the [CRD CommunicationRequest Profile](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-communicationrequest.html).
+
+    # Testing Methodology
+    ## Read
+    First, Inferno will attempt to read each CommunicationRequest resource id provided in
+    the CommunicationRequest IDs input. The server SHOULD be capable of returning a
+    CommunicationRequest resource using the read interaction.
+
+    ## Profile Validation
+    Each resource returned from the read step SHALL conform to
+    the [CRD CommunicationRequest Profile](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-communicationrequest.html).
+    Each element is checked against terminology binding and cardinality requirements.
+
+    )
+    id :communication_request_group
+    optional
+    run_as_group
+
+    input :communication_request_ids,
+          title: 'Communication Request IDs',
+          description: 'Comma separated list of CommunicationRequest IDs',
+          optional: true
+
+    test from: :communication_request_read
+    test from: :communication_request_validation
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/coverage/coverage_read.rb

@@ -0,0 +1,29 @@
+require_relative '../../read_test'
+
+module DaVinciDTRTestKit
+  class CoverageReadTest < Inferno::Test
+    include DaVinciDTRTestKit::ReadTest
+
+    title 'Server returns correct Coverage resource from Coverage read interaction'
+    description 'A server SHALL support the Coverage read interaction.'
+
+    id :coverage_read
+    output :coverage_resources
+
+    def resource_type
+      'Coverage'
+    end
+
+    def coverage_id_list
+      return [nil] unless respond_to? :coverage_ids
+
+      coverage_ids&.split(',')&.map(&:strip)
+    end
+
+    run do
+      resources = perform_read_test(coverage_id_list, resource_type)
+
+      output coverage_resources: resources.to_json
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/coverage/coverage_validation.rb

@@ -0,0 +1,35 @@
+require_relative '../../validation_test'
+
+module DaVinciDTRTestKit
+  class CoverageValidationTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+
+    title 'Coverage resources returned during previous tests conform to the CRD Coverage'
+    description %(
+This test verifies resources returned from the read step conform to
+the [CRD Coverage](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-coverage).
+Systems must demonstrate at least one valid example in order to pass this test.
+
+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.
+
+    )
+
+    id :coverage_validation
+    input :coverage_resources,
+          optional: true
+
+    def resource_type
+      'Coverage'
+    end
+
+    run do
+      skip_if(coverage_ids.nil?, "No `#{resource_type}` IDs provided, skipping test.")
+      perform_profile_validation_test(coverage_resources, resource_type,
+                                      'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage|2.0.1')
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/coverage_group.rb

@@ -0,0 +1,38 @@
+require_relative 'coverage/coverage_read'
+require_relative 'coverage/coverage_validation'
+
+module DaVinciDTRTestKit
+  class CoverageGroup < Inferno::TestGroup
+    title 'CRD Coverage Tests'
+    short_description 'Verify support for the server capabilities required by the CRD Coverage Profile'
+    description %(
+      # Background
+
+    The CRD Coverage sequence verifies that the system under test is
+    able to provide correct responses for Coverage queries. These queries
+    must return resources conforming to the [CRD Coverage Profile](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-coverage.html).
+
+    # Testing Methodology
+    ## Read
+    First, Inferno will attempt to read each Coverage resource id provided in
+    the Coverage IDs input. The server SHALL be capable of returning a
+    Coverage resource using the read interaction.
+
+    ## Profile Validation
+    Each resource returned from the read step SHALL conform to
+    the [CRD Coverage Profile](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-profile-coverage.html).
+    Each element is checked against terminology binding and cardinality requirements.
+
+    )
+    id :coverage_group
+    run_as_group
+
+    input :coverage_ids,
+          title: 'Coverage IDs',
+          description: 'Comma separated list of Coverage IDs',
+          optional: true
+
+    test from: :coverage_read
+    test from: :coverage_validation
+  end
+end

data/lib/davinci_dtr_test_kit/profiles/device_request/device_request_read.rb

@@ -0,0 +1,29 @@
+require_relative '../../read_test'
+
+module DaVinciDTRTestKit
+  class DeviceRequestReadTest < Inferno::Test
+    include DaVinciDTRTestKit::ReadTest
+
+    title 'Server returns correct DeviceRequest resource from DeviceRequest read interaction'
+    description 'A server SHOULD support the DeviceRequest read interaction.'
+
+    id :device_request_read
+    output :device_request_resources
+
+    def resource_type
+      'DeviceRequest'
+    end
+
+    def device_request_id_list
+      return [nil] unless respond_to? :device_request_ids
+
+      device_request_ids&.split(',')&.map(&:strip)
+    end
+
+    run do
+      resources = perform_read_test(device_request_id_list, resource_type)
+
+      output device_request_resources: resources.to_json
+    end
+  end
+end