davinci_dtr_test_kit 0.11.1 → 0.13.0

data/lib/davinci_dtr_test_kit/cql_test.rb

@@ -14,25 +14,21 @@ module DaVinciDTRTestKit
     end
 
     def cqf_reference_libraries
-      @cqf_reference_libraries ||= Set.new
+      scratch[:cqf_reference_libraries] ||= Set.new
     end
 
     def library_urls
-      @@library_urls ||= Set.new
+      scratch[:library_urls] ||= Set.new
     end
 
     def library_names
-      @@library_names ||= Set.new
+      scratch[:library_names] ||= Set.new
     end
 
     def found_questionnaire
       @found_questionnaire ||= false
     end
 
-    def found_bad_library_reference
-      @@found_bad_library_reference ||= false
-    end
-
     def found_duplicate_library_name
       @found_duplicate_library_name ||= false
     end
@@ -52,97 +48,63 @@ module DaVinciDTRTestKit
       extension_presence.each_key { |k| extension_presence[k] = false }
     end
 
-    def questionnaire_extensions_test(response)
-      resource = process_response(response)
-      assert !resource.nil?, 'Response is null or not a valid type.'
+    def evaluate_responses_extensions(resource)
       found_questionnaire = false
-      if resource.instance_of? Array
-        resource.each do |individual_resource|
-          next unless individual_resource.resourceType == 'QuestionnaireResponse'
+      resource.each do |individual_resource|
+        next unless individual_resource.resourceType == 'QuestionnaireResponse'
 
-          individual_resource.contained.each_with_index do |questionnaire, q_index|
-            # Do out put parameters have a bundle?
-            next unless questionnaire.resourceType == 'Questionnaire'
+        individual_resource.contained.each_with_index do |questionnaire, q_index|
+          # Do out put parameters have a bundle?
+          next unless questionnaire.resourceType == 'Questionnaire'
 
-            # check the libraries first so references in questionnaires can be checked after
-            found_questionnaire = true
-            check_questionnaire_extensions(questionnaire, q_index)
-          end
+          # check the libraries first so references in questionnaires can be checked after
+          found_questionnaire = true
+          check_questionnaire_extensions(questionnaire, q_index)
         end
-      elsif resource.resourceType == 'Parameters'
-        resource.parameter.each do |param|
-          # Do out put parameters have a bundle?
-          next unless param.resource.resourceType == 'Bundle'
+      end
+      found_questionnaire
+    end
 
-          param.resource.entry.each_with_index do |entry, q_index|
-            # check questionnaire extensions
-            next unless entry.resource.resourceType == 'Questionnaire'
+    def evaluate_parameters_extensions(resource)
+      found_questionnaire = false
+      resource.parameter.each do |param|
+        # Do out put parameters have a bundle?
+        next unless param.resource.resourceType == 'Bundle'
 
-            found_questionnaire = true
-            check_questionnaire_extensions(entry.resource, q_index)
-            ## NEED TO FIGURE OUT HOW TO FAIL TEST WHEN POORLY FORMATTED EXPRESSIONS FOUND
-          end
+        param.resource.entry.each_with_index do |entry, q_index|
+          # check questionnaire extensions
+          next unless entry.resource.resourceType == 'Questionnaire'
+
+          found_questionnaire = true
+          check_questionnaire_extensions(entry.resource, q_index)
+          ## NEED TO FIGURE OUT HOW TO FAIL TEST WHEN POORLY FORMATTED EXPRESSIONS FOUND
         end
       end
-      check_library_references
-      assert found_questionnaire, 'No questionnaires found.'
-      assert extension_presence.value?(true), 'No extensions found. Questionnaire must demonstrate prepopulation.'
-      assert cql_presence['variable'], 'Variable expression logic not written in CQL.'
-      assert cql_presence['launch_context'], 'Launch context expression logic not written in CQL.'
-      assert cql_presence['pop_context'], 'Population context expression logic not written in CQL.'
+      found_questionnaire
     end
 
-    def questionnaire_items_test(response, final_cql_test)
+    # extensions
+    def questionnaire_extensions_test(response)
       resource = process_response(response)
       assert !resource.nil?, 'Response is null or not a valid type.'
-      found_bundle = found_questionnaire = false
-      # are extensions present in any questionnaire?
+      found_questionnaire = false
       if resource.instance_of? Array
-        resource.each_with_index do |individual_resource, q_index|
-          next unless individual_resource.resourceType == 'QuestionnaireResponse'
-
-          individual_resource.contained.each do |questionnaire|
-            # Do out put parameters have a bundle?
-            next unless questionnaire.resourceType == 'Questionnaire'
-
-            # check the libraries first so references in questionnaires can be checked after
-            found_questionnaire = true
-            check_questionnaire_items(questionnaire, q_index)
-          end
-        end
+        found_questionnaire = evaluate_responses_extensions(resource)
       elsif resource.resourceType == 'Parameters'
-        resource.parameter.each do |param|
-          # Do out put parameters have a bundle?
-          next unless param.resource.resourceType == 'Bundle'
-
-          found_bundle = true
-          # check the libraries first so references in questionnaires can be checked after
-          param.resource.entry.each_with_index do |entry, q_index|
-            if entry.resource.resourceType == 'Questionnaire'
-              found_questionnaire = true
-              check_questionnaire_items(entry.resource, q_index)
-            end
-          end
-        end
-        assert found_bundle, 'No questionnaire bundles found.'
-      end
-      begin
-        assert found_questionnaire, 'No questionnaires found.'
-        assert !found_non_cql_expression, 'Found non-cql expression.'
-        assert !found_bad_library_reference, 'Found expression with no or incorrect reference to library name.'
-        assert extension_presence.value?(true), 'No extensions found. Questionnaire must demonstrate prepopulation.'
-        assert cql_presence['init_expression'], 'Initial expression logic not written in CQL.'
-        assert cql_presence['candidate_expression'], 'Candidate expression logic not written in CQL.'
-        assert cql_presence['context_expression'], 'Context expression logic not written in CQL.'
-      ensure
-        reset_cql_tests if final_cql_test
+        found_questionnaire = evaluate_parameters_extensions(resource)
       end
+      check_library_references
+      assert found_questionnaire, 'No questionnaires found.'
+      assert extension_presence.value?(true), 'No extensions found. Questionnaire must demonstrate prepopulation.'
+      assert cql_presence['variable'], 'Variable expression logic not written in CQL.'
+      assert cql_presence['launch_context'], 'Launch context expression logic not written in CQL.'
+      assert cql_presence['pop_context'], 'Population context expression logic not written in CQL.'
     end
 
     def check_questionnaire_extensions(questionnaire, q_index)
       # are extensions present in this questionnaire?
       found_launch_context = found_variable = found_pop_context = found_cqf_lib = false
-      cqf_count = 0
+      cqf_count = total_cqf_libs(questionnaire.extension)
       misformatted_expressions = []
       questionnaire.extension.each_with_index do |extension, index|
         if extension.url == 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-launchContext'
@@ -165,13 +127,77 @@ module DaVinciDTRTestKit
         end
         next unless extension.url == 'http://hl7.org/fhir/StructureDefinition/cqf-library'
 
-        cqf_count += 1
         cqf_reference_libraries.add(extension.valueCanonical)
         found_cqf_lib = true
         extension_presence['found_min_cqf_lib'] = true
 
         check_for_cql(extension, '', index, q_index, extension.url)
       end
+      add_launch_context_messages(found_launch_context, found_variable, found_pop_context, found_cqf_lib, q_index)
+      return if cqf_count < 1
+
+      add_formatting_messages(misformatted_expressions, q_index)
+      assert misformatted_expressions.compact.empty?, 'Expression in questionnaire misformatted.'
+    end
+
+    # items
+    def evaluate_responses_items(resource)
+      found_questionnaire = false
+      resource.each_with_index do |individual_resource, q_index|
+        next unless individual_resource.resourceType == 'QuestionnaireResponse'
+
+        individual_resource.contained.each do |questionnaire|
+          next unless questionnaire.resourceType == 'Questionnaire'
+
+          # check the libraries first so references in questionnaires can be checked after
+          found_questionnaire = true
+          check_questionnaire_items(questionnaire, q_index)
+        end
+      end
+      found_questionnaire
+    end
+
+    def evaluate_parameters_items(resource)
+      found_bundle = found_questionnaire = false
+      resource.parameter.each do |param|
+        next unless param.resource.resourceType == 'Bundle'
+
+        found_bundle = true
+        # check the libraries first so references in questionnaires can be checked after
+        param.resource.entry.each_with_index do |entry, q_index|
+          if entry.resource.resourceType == 'Questionnaire'
+            found_questionnaire = true
+            check_questionnaire_items(entry.resource, q_index)
+          end
+        end
+      end
+      [found_bundle, found_questionnaire]
+    end
+
+    def questionnaire_items_test(response, final_cql_test)
+      resource = process_response(response)
+      assert !resource.nil?, 'Response is null or not a valid type.'
+      found_questionnaire = false
+      # are extensions present in any questionnaire?
+      if resource.instance_of? Array
+        found_questionnaire = evaluate_responses_items(resource)
+      elsif resource.resourceType == 'Parameters'
+        found_bundle, found_questionnaire = evaluate_parameters_items(resource)
+        assert found_bundle, 'No questionnaire bundles found.'
+      end
+      begin
+        assert found_questionnaire, 'No questionnaires found.'
+        assert !found_non_cql_expression, 'Found non-cql expression.'
+        assert extension_presence.value?(true), 'No extensions found. Questionnaire must demonstrate prepopulation.'
+        assert cql_presence['init_expression'], 'Initial expression logic not written in CQL.'
+        assert cql_presence['candidate_expression'], 'Candidate expression logic not written in CQL.'
+        assert cql_presence['context_expression'], 'Context expression logic not written in CQL.'
+      ensure
+        reset_cql_tests if final_cql_test
+      end
+    end
+
+    def add_launch_context_messages(found_launch_context, found_variable, found_pop_context, found_cqf_lib, q_index)
       unless found_launch_context
         messages << { type: 'info',
                       message: format_markdown("[questionnaire #{q_index + 1}] included no launch context.") }
@@ -186,19 +212,44 @@ module DaVinciDTRTestKit
                       message: format_markdown("[questionnaire #{q_index + 1}]
                        included no item population context.") }
       end
-      unless found_cqf_lib
-        messages << { type: 'info',
-                      message: format_markdown("[questionnaire #{q_index + 1}]
+      return if found_cqf_lib
+
+      messages << { type: 'info',
+                    message: format_markdown("[questionnaire #{q_index + 1}]
                       included no cqf library.") }
-      end
-      return if cqf_count < 1
+    end
 
+    def add_formatting_messages(misformatted_expressions, q_index)
       misformatted_expressions.compact.each do |idx|
         messages << { type: 'info',
                       message: format_markdown("[expression #{idx + 1}] in [questionnaire #{q_index + 1}]
                       does not begin with a reference to an included library name.") }
       end
-      assert misformatted_expressions.compact.empty?, 'Expression in questionnaire misformatted.'
+    end
+
+    def total_cqf_libs(extensions)
+      cqf_count = 0
+      extensions.each do |extension|
+        next unless extension.url == 'http://hl7.org/fhir/StructureDefinition/cqf-library'
+
+        cqf_count += 1
+      end
+      cqf_count
+    end
+
+    def add_item_messages(found_item_expressions, q_index)
+      unless found_item_expressions['found_candidate_expression']
+        messages << { type: 'info',
+                      message: format_markdown("[questionnaire #{q_index + 1}] included no candidate expression.") }
+      end
+      unless found_item_expressions['found_init_expression']
+        messages << { type: 'info',
+                      message: format_markdown("[questionnaire #{q_index + 1}] included no initial expression.") }
+      end
+      return if found_item_expressions['found_context_expression']
+
+      messages << { type: 'info',
+                    message: format_markdown("[questionnaire #{q_index + 1}] included no context expression.") }
     end
 
     def check_questionnaire_items(questionnaire, q_index)
@@ -206,13 +257,9 @@ module DaVinciDTRTestKit
       found_item_expressions = { 'found_init_expression' => false,
                                  'found_candidate_expression' => false,
                                  'found_context_expression' => false }
-      cqf_count = 0
+      cqf_count = total_cqf_libs(questionnaire.extension)
       misformatted_expressions = []
-      questionnaire.extension.each do |extension|
-        next unless extension.url == 'http://hl7.org/fhir/StructureDefinition/cqf-library'
 
-        cqf_count += 1
-      end
       # check questionnaire items
       questionnaire.item.each_with_index do |item, index|
         misformatted_expressions.concat(check_nested_items(item, index, q_index, found_item_expressions, item.linkId))
@@ -222,18 +269,8 @@ module DaVinciDTRTestKit
                                                            index, q_index, found_item_expressions, item.linkId)
         end
       end
-      unless found_item_expressions['found_candidate_expression']
-        messages << { type: 'info',
-                      message: format_markdown("[questionnaire #{q_index + 1}] included no candidate expression.") }
-      end
-      unless found_item_expressions['found_init_expression']
-        messages << { type: 'info',
-                      message: format_markdown("[questionnaire #{q_index + 1}] included no initial expression.") }
-      end
-      unless found_item_expressions['found_context_expression']
-        messages << { type: 'info',
-                      message: format_markdown("[questionnaire #{q_index + 1}] included no context expression.") }
-      end
+      add_item_messages(found_item_expressions, q_index)
+      # only care about formatting when there are multiple cqf libs
       return if cqf_count < 1
 
       misformatted_expressions.compact.to_set.each do |idx|
@@ -244,6 +281,33 @@ module DaVinciDTRTestKit
       assert misformatted_expressions.compact.to_set.empty?, 'Expression in questionnaire misformatted.'
     end
 
+    def evaluate_library(entry, lib_index)
+      found_cql = found_elm = false
+      entry.resource.content.each do |content|
+        if content.data.nil?
+          messages << { type: 'info',
+                        message: format_markdown("[library #{lib_index + 1}] content element included no data.") }
+        end
+        if content.contentType == 'text/cql'
+          found_cql = true
+        elsif content.contentType == 'application/elm+json'
+          found_elm = true
+        else
+          messages << { type: 'info',
+                        message: format_markdown("[library #{lib_index + 1}] has non-cql/elm content.") }
+          true
+        end
+        next unless library_names.include? entry.resource.name
+
+        found_duplicate_library_name = true
+        messages << { type: 'info', message: format_markdown("[library #{lib_index + 1}] has a name,
+         #{entry.resource.name}, that is already included in the bundle.") }
+        assert !found_duplicate_library_name, 'Found duplicate library names - all names must be unique.'
+      end
+      assert found_cql, "[library #{lib_index + 1}] does not include CQL."
+      assert found_elm, "[library #{lib_index + 1}] does not include ELM."
+    end
+
     def check_libraries(payer_response)
       resource = process_response(payer_response)
       assert !resource.nil?, 'Response is null or not a valid type.'
@@ -259,32 +323,9 @@ module DaVinciDTRTestKit
           next unless entry.resource.resourceType == 'Library'
 
           found_libraries = true
-          found_cql = found_elm = false
           library_urls.add(entry.resource.url) unless entry.resource.url.nil?
-          entry.resource.content.each do |content|
-            if content.data.nil?
-              messages << { type: 'info',
-                            message: format_markdown("[library #{index + 1}] content element included no data.") }
-            end
-            if content.contentType == 'text/cql'
-              found_cql = true
-            elsif content.contentType == 'application/elm+json'
-              found_elm = true
-            else
-              messages << { type: 'info',
-                            message: format_markdown("[library #{index + 1}] has non-cql/elm content.") }
-              true
-            end
-            next unless library_names.include? entry.resource.name
-
-            found_duplicate_library_name = true
-            messages << { type: 'info', message: format_markdown("[library #{index + 1}] has a name,
-             #{entry.resource.name}, that is already included in the bundle.") }
-            assert !found_duplicate_library_name, 'Found duplicate library names - all names must be unique.'
-          end
+          evaluate_library(entry, index)
           library_names.add(entry.resource.name)
-          assert found_cql, "[library #{index + 1}] does not include CQL."
-          assert found_elm, "[library #{index + 1}] does not include ELM."
         end
         assert found_libraries, 'No Libraries found.'
       end
@@ -364,21 +405,25 @@ module DaVinciDTRTestKit
                   end
     end
 
+    def q_responses(response)
+      questionnaire_responses = []
+      response.each do |resource|
+        fhir_resource = FHIR.from_contents(resource.response_body)
+        questionnaire_responses << fhir_resource if fhir_resource.resourceType == 'QuestionnaireResponse'
+        next unless resource.instance_of? Inferno::Entities::Request
+
+        if fhir_resource.resourceType == 'Questionnaire' || fhir_resource.resourceType == 'Parameters'
+          return fhir_resource
+        end
+      end
+      questionnaire_responses
+    end
+
     def process_response(response)
       if response.instance_of?(FHIR::Parameters) || response.instance_of?(FHIR::QuestionnaireResponse)
         return response
       elsif response.instance_of? Array
-        questionnaire_responses = []
-        response.each do |resource|
-          fhir_resource = FHIR.from_contents(resource.response_body)
-          questionnaire_responses << fhir_resource if fhir_resource.resourceType == 'QuestionnaireResponse'
-          next unless resource.instance_of? Inferno::Entities::Request
-
-          if fhir_resource.resourceType == 'Questionnaire' || fhir_resource.resourceType == 'Parameters'
-            return fhir_resource
-          end
-        end
-        return questionnaire_responses
+        return q_responses(response)
       end
 
       nil

data/lib/davinci_dtr_test_kit/docs/dtr_full_ehr_suite_description_v201.md

@@ -0,0 +1,127 @@
+The Da Vinci DTR Test Kit Full EHR Suite validates the conformance of SMART apps
+to the STU 2 version of the HL7® FHIR®
+[Da Vinci Documentation Templates and Rules (DTR) Implementation Guide](https://hl7.org/fhir/us/davinci-dtr/STU2/).
+
+## Scope
+
+These tests are a **DRAFT** intended to allow app implementers to perform
+preliminary checks of their systems against DTR IG requirements and [provide
+feedback](https://github.com/inferno-framework/davinci-dtr-test-kit/issues)
+on the tests. Future versions of these tests may validate other
+requirements and may change the test validation logic.
+
+## Test Methodology
+
+Inferno will simulate a DTR payer server that will response to
+requests for questionnaires for the EHR under test to interact with. 
+The EHR will be expected to initiate requests to Inferno to elicit responses. Over the
+course of these interactions, Inferno will seek to observe conformant handling of 
+DTR workflows and requirements around the retrieval, completion, and storage of
+questionnaires.
+
+Tests within this suite are associated with specific questionnaires that the EHR will
+demonstrate completion of. In each case, the EHR under test will initiate a request to
+the payer server simulated by Inferno for a questionnaire using the 
+`$questionnaire-package` operation. Inferno will always return the specific questionnaire
+for the test being executed regardless of the input provided by the EHR, though it must
+be conformant. The EHR will then be asked to complete the questionnaire, including
+- Pre-populating answers based on directives in the questionnaire
+- Rendering the questionnaire for users and allowing them to make additional updates.
+  These tests can include specific directions on details to include in the completed
+  questionnaire.
+- Storing the completed questionnaire for future use as a FHIR QuestionnaireResponse.
+
+EHRs will be required to complete all questionnaires in the suite, which in aggregate
+contain all questionnaire features that apps must support. Currently, the suite includes
+one questionnaire:
+1. A fictious "dinner" questionnaire created for these tests. It tests basic
+   item rendering and pre-population.
+Additional questionnaires will be added in the future.
+
+All requests sent by the app will be checked 
+for conformance to the DTR IG requirements individually and used in aggregate to determine
+whether required features and functionality are present. HL7® FHIR® resources are
+validated with the Java validator using `tx.fhir.org` as the terminology server.
+
+## Running the Tests
+
+### Quick Start
+
+In order to run these tests, EHRs must be configured to interact with Inferno's simulated
+payer server endpoint. The endpoint will be `[URL prefix]/custom/dtr_full_ehr/fhir` where
+`[URL prefix]` can be inferred from the URL of the test session which will be of the form 
+`[URL prefix]/dtr_full_ehr/[session id]`.
+
+In order for Inferno to associate requests sent to locations under these base URLs with this session,
+it needs to know the bearer token that the EHR will send on requests, for which 
+there are two options.
+
+1. If you want to choose your own bearer token, then
+    1. Select the "2. Basic Workflows" test from the list on the left (or other target test). 
+    2. Click the '*Run All Tests*' button on the right.
+    3. In the "access_token" field, enter the bearer token that will be sent by the client 
+       under test (as part of the Authorization header - `Bearer <provided value>`).
+    4. Click the '*Submit*' button at the bottom of the dialog.
+2. If you want to use a client_id to obtain an access token, then
+    1. Click the '*Run All Tests*' button on the right.
+    2. Provide the EHR's registered id "client_id" field of the input (NOTE, Inferno 
+       doesn't support the registration API, so this must be obtained from another
+       system or configured manually).
+    3. Click the '*Submit*' button at the bottom of the dialog.
+    4. Make a token request that includes the specified client id to the
+        `[URL prefix]/custom/dtr_full_ehr/mock_auth/token` endpoint to get
+        an access token to use on the request of the requests.
+
+In either case, the tests will continue from that point. Further executions of tests under
+this session will also use the selected bearer token.
+
+Note: authentication options for these tests have not been finalized and are subject to change.
+
+### Postman-based Demo
+
+If you do not have a DTR Full EHR but would like to try the tests out, you can use
+[this Postman collection](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/config/DTR%20Full%20EHR%20Tests%20Postman%20Demo.postman_collection.json)
+to make requests against Inferno. This does not include the capability to render and complete the
+questionnaires, but does have samples of correctly and incorrectly completed QuestionnaireResponses.
+To run the tests using this approach:
+
+1. Install [postman](https://www.postman.com/downloads/).
+1. Import [this Postman collection](https://github.com/inferno-framework/davinci-dtr-test-kit/blob/main/config/DTR%20Full%20EHR%20Tests%20Postman%20Demo.postman_collection.json).
+1. Start a Da Vinci DTR Full EHR Test Suite Session.
+1. Update the postman collection configuration variables found by opening the "DTR Full EHR
+   Tests Postman Demo" collection and selecting the "Variables" tab.
+   - **base_url**: corresponds to the where the test suite session is running. Defaults to 
+   `inferno.healthit.gov`. If running in another location, see guidance on the "Overview" tab
+   of the postman collection.
+   - **access_token**: note the "Current value" (update if desired) for use later.
+1. Return to Inferno and in the test list at the left, select *2 Static Questionnaire Workflow*.
+1. Click the "Run All Tests" button in the upper right.
+1. Add the **access_token** configured in postman to the Inferno input with the same name
+1. Click the "Submit" button in Inferno.
+1. Attest that the EHR has launched its DTR workflow in Inferno by clicking the link for the **true** response.
+1. Once the next wait dialog has appeared within Inferno asking for a `$questionnaire-package` 
+   request, use postman to submit the "Questionnaire Package for Dinner (Static)" request. Confirm
+   that the response that looks similar to the "Example Working Response" in postman
+   and click the link to continue the tests.
+1. Attest to the remainder of the tests as desired to get a sense for what is involved in testing
+   with an actual EHR implementation. To see what a valid QuestionnaireResponse looks like, see
+   the "Sample QuestionnaireResponse for Dinner (Static) ..." request in postman.
+
+## Limitations
+
+The DTR IG is a complex specification and these tests currently validate conformance to only
+a subset of IG requirements. Future versions of the test suite will test further
+features. A few specific features of interest are listed below.
+
+### Heavy Reliance on Attestations
+
+Currently, these test kits do not have access to the QuestionnaireResponse and so validation
+that the EHR performed CQL calculations and generated a conformant QuestionnaireResponse
+based on pre-population and manual answers is left to a user attestation rather than a
+mechanical check. Some level of mechanical checks are expected to be added in the future.
+
+### Questionnaire Feature Coverage
+
+Not all questionnaire features that are must support within the DTR IG are currently represented
+in questionnaires tested by the IG. Adaptive questionnaires are a notable omission.
+Additional questionnaires testing additional features will be added in the future.

data/lib/davinci_dtr_test_kit/docs/dtr_light_ehr_suite_description_v201.md

@@ -0,0 +1,29 @@
+The Da Vinci DTR Test Kit Light EHR Suite validates the conformance of SMART apps
+to the STU 2 version of the HL7® FHIR®
+[Da Vinci Documentation Templates and Rules (DTR) Implementation Guide](https://hl7.org/fhir/us/davinci-dtr/STU2/).
+
+## Scope
+
+These tests are a **DRAFT** intended to allow app implementers to perform
+preliminary checks of their systems against DTR IG requirements and [provide
+feedback](https://github.com/inferno-framework/davinci-dtr-test-kit/issues)
+on the tests. Future versions of these tests may validate other
+requirements and may change the test validation logic.
+
+## Test Methodology
+
+Inferno will simulate a DTR SMART App that will connect to the DTR Light EHR system under test. The tester will need to launch Inferno using either an EHR launch or a Standalone launch.
+
+Once the connection between the DTR SMART App and the DTR Light EHR is established, tests within this suite check that the DTR Light EHR API is conformant to US Core and any other requirements outlined in the [Light DTR EHR Capability Statement](https://hl7.org/fhir/us/davinci-dtr/STU2/CapabilityStatement-light-dtr-ehr.html#root).
+
+## Running the Tests
+
+If you would like to try out the tests but don't have a DTR payer server implementation, you can run these tests against the [public instance of the Inferno Reference Server](https://inferno.healthit.gov/reference-server/r4/) by using the Inferno Reference Server preset in the test suite.
+
+In order to get the Inferno QA Reference Server to do an EHR launch, navigate to https://inferno.healthit.gov/reference-server/app/app-launch and use https://inferno.healthit.gov/custom/smart/launch as the App Launch URL.
+
+## Limitations
+
+The DTR IG is a complex specification and these tests currently validate conformance to only
+a subset of IG requirements. Future versions of the test suite will test further
+features.

data/lib/davinci_dtr_test_kit/dtr_full_ehr_suite.rb

@@ -1,7 +1,7 @@
 require_relative 'ext/inferno_core/runnable'
 require_relative 'ext/inferno_core/record_response_route'
 require_relative 'ext/inferno_core/request'
-require_relative 'client_groups/resp_assist_device/dtr_full_ehr_questionnaire_workflow_group'
+require_relative 'client_groups/dinner_static/dtr_full_ehr_questionnaire_workflow_group'
 require_relative 'auth_groups/oauth2_authentication_group'
 require_relative 'mock_payer'
 require_relative 'version'
@@ -9,19 +9,11 @@ require_relative 'version'
 module DaVinciDTRTestKit
   class DTRFullEHRSuite < Inferno::TestSuite
     extend MockPayer
+    extend MockAuthServer
 
     id :dtr_full_ehr
     title 'Da Vinci DTR Full EHR Test Suite'
-    description %(
-        # Da Vinci DTR Full EHR Test Suite
-
-        This suite validates that an EHR or other application can act
-        as a full DTR application requesting questionnaires from a
-        payer server and using local data to complete and store them.
-        Inferno will act as payer server returning questionnaires
-        in response to queries from the system under test and validating
-        that they can be completed as expected.
-      )
+    description File.read(File.join(__dir__, 'docs', 'dtr_full_ehr_suite_description_v201.md'))
 
     version VERSION
 
@@ -74,6 +66,6 @@ module DaVinciDTRTestKit
     end
 
     group from: :oauth2_authentication
-    group from: :dtr_full_ehr_questionnaire_workflow
+    group from: :dtr_full_ehr_static_dinner_questionnaire_workflow
   end
 end