davinci_dtr_test_kit 0.12.0 → 0.14.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,20 @@ 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.'
-      found_questionnaire = false
-      if resource.instance_of? Array
-        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'
-
-            # check the libraries first so references in questionnaires can be checked after
-            found_questionnaire = true
-            check_questionnaire_extensions(questionnaire, q_index)
-          end
-        end
-      elsif resource.resourceType == 'Parameters'
-        resource.parameter.each do |param|
-          # Do out put parameters have a bundle?
-          next unless param.resource.resourceType == 'Bundle'
-
-          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
-      end
+    def verify_questionnaire_extensions(questionnaires)
+      assert questionnaires&.any? && questionnaires.all? { |q| q.is_a? FHIR::Questionnaire }, 'No questionnaires found.'
+      questionnaires.each_with_index { |q, q_index| check_questionnaire_extensions(q, q_index) }
       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 questionnaire_items_test(response, final_cql_test)
-      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?
-      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
-      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
-      end
-    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 +84,35 @@ 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
+
+    def verify_questionnaire_items(questionnaires, final_cql_test: false)
+      assert questionnaires&.any? && questionnaires.all? { |q| q.is_a? FHIR::Questionnaire }, 'No questionnaires found.'
+      questionnaires.each_with_index { |q, q_index| check_questionnaire_items(q, q_index) }
+
+      begin
+        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 +127,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 +172,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 +184,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,51 +196,43 @@ module DaVinciDTRTestKit
       assert misformatted_expressions.compact.to_set.empty?, 'Expression in questionnaire misformatted.'
     end
 
-    def check_libraries(payer_response)
-      resource = process_response(payer_response)
-      assert !resource.nil?, 'Response is null or not a valid type.'
-      found_bundle = found_libraries = false
-      # are extensions present in any questionnaire?
-      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, index|
-          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
-          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."
+    def evaluate_library(library)
+      found_cql = found_elm = false
+      library.content.each do |content|
+        if content.data.nil?
+          messages << { type: 'info',
+                        message: format_markdown("[library #{library.url}] 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 #{library.url}] has non-cql/elm content.") }
+          true
         end
-        assert found_libraries, 'No Libraries found.'
+        next unless library_names.include? library.name
+
+        found_duplicate_library_name = true
+        messages << { type: 'info', message: format_markdown("[library #{library.url}] has a name,
+         #{library.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 #{library.url}] does not include CQL."
+      assert found_elm, "[library #{library.url}] does not include ELM."
+    end
+
+    def check_libraries(questionnaire_bundles)
+      libraries = extract_libraries_from_bundles(questionnaire_bundles)
+
+      assert libraries.any?, 'No Libraries found.'
+
+      libraries.each do |lib|
+        library_urls.add(lib.url) unless lib.url.nil?
+        evaluate_library(lib)
+        library_names.add(lib.name)
       end
-      assert found_bundle, 'No questionnaire bundles found.'
     end
 
     def check_library_references
@@ -364,24 +308,22 @@ module DaVinciDTRTestKit
                   end
     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
-      end
+    def extract_contained_questionnaires(questionnaire_responses)
+      questionnaire_responses&.filter_map do |qr|
+        qr.contained&.filter { |resource| resource.is_a?(FHIR::Questionnaire) }
+      end&.flatten&.compact
+    end
+
+    def extract_questionnaires_from_bundles(questionnaire_bundles)
+      questionnaire_bundles.filter_map do |qb|
+        qb.entry.filter_map { |entry| entry.resource if entry.resource.is_a?(FHIR::Questionnaire) }
+      end&.flatten&.compact
+    end
 
-      nil
+    def extract_libraries_from_bundles(questionnaire_bundles)
+      questionnaire_bundles.filter_map do |qb|
+        qb.entry.filter_map { |entry| entry.resource if entry&.resource.is_a?(FHIR::Library) }
+      end&.flatten&.compact
     end
   end
 end

data/lib/davinci_dtr_test_kit/create_test.rb

@@ -0,0 +1,25 @@
+module DaVinciDTRTestKit
+  module CreateTest
+    def perform_create_test(create_resources, resource_type)
+      skip_if(create_resources.blank?, "No `#{resource_type}` resources to create provided, skipping test.")
+      assert_valid_json(create_resources)
+      create_resources_list = JSON.parse(create_resources)
+      skip_if(!create_resources_list.is_a?(Array), 'Resources to create not inputted in list format, skipping test.')
+
+      valid_create_resources =
+        create_resources_list
+          .compact_blank
+          .map { |resource| FHIR.from_contents(resource.to_json) }
+          .select { |resource| resource.resourceType == resource_type }
+          .select { |resource| resource_is_valid?(resource:) }
+
+      skip_if(valid_create_resources.blank?,
+              %(No valid #{resource_type} resources were provided to send in Create requests, skipping test.))
+
+      valid_create_resources.each do |create_resource|
+        fhir_create(create_resource)
+        assert_response_status(201)
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/docs/dtr_full_ehr_suite_description_v201.md

@@ -13,32 +13,38 @@ 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. 
+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 
+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 
+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
+for the test being executed regardless of the input provided by the EHR, though Inferno will
+check that the input is 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.
+- For adaptive questionnaires only, getting additional questions using the `$next-question`
+  operation until the questionnaire is complete.
 - 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 
+1. Standard and adaptive styles of a fictitious "dinner" questionnaire created for these tests. 
+   They test basic item rendering, control flow, and pre-population.
+
+Additional questionnaires covering further features 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.
@@ -49,28 +55,28 @@ validated with the Java validator using `tx.fhir.org` as the terminology server.
 
 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]` 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 
+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.
+   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.
+   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.
@@ -85,21 +91,30 @@ to make requests against Inferno. This does not include the capability to render
 questionnaires, but does have samples of correctly and incorrectly completed QuestionnaireResponses.
 To run the tests using this approach:
 
+#### Setup
 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).
+
+#### Startup
 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.
+   - **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*.
+
+#### Dinner Questionnaire (Standard)
+
+For the standard (static) questionnaire demo, use the requests in the _Static Dinner_ folder in the 
+Postman collection.
+
+1. Return to the Inferno test session 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` 
+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.
@@ -107,21 +122,64 @@ To run the tests using this approach:
    with an actual EHR implementation. To see what a valid QuestionnaireResponse looks like, see
    the "Sample QuestionnaireResponse for Dinner (Static) ..." request in postman.
 
+#### Dinner Questionnaire (Adaptive)
+
+For the adaptive questionnaire demo, use the requests in the _Adaptive Dinner_ folder in the 
+Postman collection.
+
+1. Return to the Inferno test session and in the test list at the left, select _3 Adaptive 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 (if not already present)
+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 **Adaptive Questionnaire Retrieval** wait dialog has appeared within Inferno asking 
+   for `$questionnaire-package` and `$next-question`
+   requests, use postman to submit the "Questionnaire Package for Dinner" request followed by the
+   "Initial Next Question" request. Confirm
+   that the response that looks similar to the "Example Response" in postman
+   and click the link to continue the tests.
+1. Attest to the next several attestation wait dialogs as desired to get a sense for what is involved
+   in testing with an actual EHR implementation.
+1. Once the **Follow-up Next Question Request** wait dialog has appeared within Inferno asking for
+   another `$next-question` request, use postman to submit the "Second Next Question" request. Confirm
+   that the response that looks similar to the "Example Response" in postman
+   and click the link to continue the tests.
+1. Once the **Last Next Question Request** wait dialog has appeared within Inferno asking for
+   another `$next-question` request, use postman to submit the "Final Next Question" request. Confirm
+   that the response that looks similar to the "Example Response" in postman
+   and click the link to continue the tests.
+
 ## 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
+### Questionnaire Response Verification
+
+Currently, these test kits do not have enough information about the data stored on
+the EHR to evaluate whether CQL evaluation populated data correctly. However, Inferno
+does ask testers to make sure that the target patient meets certain requirements and
+directs them to perform certain actions while filling out forms that allow Inferno to
+check that calculation is occuring and that the system is correctly keeping track of
+items that were pre-populated. This approach may change in future versions of these tests.
+
+### Questionnaire Response Access
+
+For standard (static) questionnaires, Full EHRs are not required by the DTR specification
+to store or expose the completed form as a FHIR QuestionnaireResponse instance, though they
+are required to store the form in some way and be able to send the QuestionnaireResponse
+representation to other systems. Currently, testers are required to provide a
+QuestionnaireResponse as an input to the tests once they have completed their workflow.
+Future versions of these tests will provide additional options for making that information
+available that are more in-line with expected system capabilities.
 
-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.
+For adaptive questionnaires, the completed QuestionnaireResponse will be present in the
+last `$next-question` invocation by the EHR, so this limitation does not apply to those
+cases.
 
 ### 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.
+in questionnaires tested by the IG. 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,34 @@
+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 Inferno's simulated DTR SMART App and the DTR Light EHR under test is established, tests within this suite will make FHIR API requests corresponding to capabilities required by the [Light DTR EHR Capability Statement](https://hl7.org/fhir/us/davinci-dtr/STU2/CapabilityStatement-light-dtr-ehr) and check that the EHR's responses are conformant.
+
+## Running the Tests
+
+If you would like to try out the tests but don't have a DTR Light EHR 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 Reference Server to do an EHR launch, navigate to https://inferno.healthit.gov/reference-server/app/app-launch and use https://inferno.healthit.gov/suites/custom/smart/launch as the App Launch URL. When using the Inferno Reference Server preset for the DTR Light EHR test suite, note that the sample patient used for testing (`dtr_bundle_patient_pat015.json`) is focused on DTR-specific data and does not have the complete set of US Core data needed to pass all the US Core tests. In addition, this preset does not test the `create` or `update` tests for DTR QuestionnaireResponse resources and PAS Task resources.
+
+## 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.
+
+## DTR 2.0.1 Corrections
+
+The DTR 2.0.1 version of the [Light EHR CapabilityStatement](http://hl7.org/fhir/us/davinci-dtr/CapabilityStatement/light-dtr-ehr) includes two pieces of missing or misleading information that have been corrected:
+
+- The 2.0.1 CapabilityStatement indicates that support for the [Coverage resource type](https://hl7.org/fhir/us/davinci-dtr/STU2/CapabilityStatement-light-dtr-ehr.html#coverage) is required when the [QuestionnaireResponse resource type was intended](https://build.fhir.org/ig/HL7/davinci-dtr/CapabilityStatement-light-dtr-ehr-311.html#questionnaireresponse) (note specifically that the `context` search parameters are not present on the Coverage resource type but is on the QuestionnaireResponse resource type).
+- The 2.0.1 CapabilityStatement does not indicate a target profile for the [Task resource type](https://hl7.org/fhir/us/davinci-dtr/STU2/CapabilityStatement-light-dtr-ehr.html#task) but the current version [clarifies](https://build.fhir.org/ig/HL7/davinci-dtr/CapabilityStatement-light-dtr-ehr-311.html#task) that the [PAS Task Profile](http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-task) is intended.
+
+This test suite verifies systems according to these corrections. Additionally, it verifies the `read` interaction for the Coverage resource type.