davinci_dtr_test_kit 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5120a6592cc4d31933d917e3214c89c8d505cdf6f8c3d5065d000588988052a8
-  data.tar.gz: c850d248ab0ae414fe399d03749d781e9f8c186525d67ba76c0d9cbad509aa17
+  metadata.gz: 0a072f135a4057afa53b8836a3436fab457fc8c1ab15199e19608732b16d16cb
+  data.tar.gz: e4942f1af9755743eab89b7a0cc8b559929ad8b4be4bed00e7e1a33b4de1b0bd
 SHA512:
-  metadata.gz: 852190bb650b3f15d3fe25e79a08ba78778aeb85f836f32f6ed5e925859f14196cfb9d5719246a625c85803db6a606526ee2e735669bed0d574adaac3b23b8d9
-  data.tar.gz: 30e796f34e0b3e6b9088a2883af8bda32f8ac26d945c66cc6d4070b925c0eb40b362b9f76036d62b07aef6cc89d41e8c133efbb95d1bfb01233aa0289bd5889b
+  metadata.gz: aae323b007b88a564283b1fc946490e3c2330d6b3081de4783c0611c25afd732327e631d7e782743bab1fe1cab797dad84bcd9403accedcdb21f464278d05f0f
+  data.tar.gz: e68f011efaa3f0785d94c7a1f683a9986474dc887f3b99492b62ccdaf5f3ecb92387be39c909872a6f6448dfc6cb8dc1520de971557d8325cf725b3fe6853771

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/dtr_full_ehr_dinner_static_questionnaire_response_conformance_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../dtr_questionnaire_response_validation'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRDinnerStaticQuestionnaireResponseConformanceTest < Inferno::Test
+    include DTRQuestionnaireResponseValidation
+
+    id :dtr_full_ehr_dinner_static_questionnaire_response_conformance
+    title 'QuestionnaireResponse is conformant'
+
+    run do
+      skip_if questionnaire_response.nil?, 'Completed QuestionnaireResponse input was blank'
+      verify_basic_conformance(questionnaire_response)
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/dtr_full_ehr_dinner_static_questionnaire_response_correctness_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../dtr_questionnaire_response_validation'
+
+module DaVinciDTRTestKit
+  class DTRFullEHRDinnerStaticQuestionnaireResponseCorrectnessTest < Inferno::Test
+    include DTRQuestionnaireResponseValidation
+
+    id :dtr_full_ehr_dinner_static_questionnaire_response_correctness
+    title 'QuestionnaireResponse is correct for the workflow'
+    description %(
+      The QuestionnaireResponse aligns with the following expectations for the workflow. This includes checks for
+      the presence of the following answers and their appropriate origin source extensions:
+
+      - PBD.1 (Last Name): `auto`
+      - PBD.2 (First Name): `override`
+      - 3.1 (dinner choice): `manual`
+    )
+
+    run do
+      skip_if questionnaire_response.nil?, 'Completed QuestionnaireResponse input was blank'
+      check_is_questionnaire_response(questionnaire_response)
+
+      questionnaire = Fixtures.questionnaire_for_test(id)
+      # questionnaire = Fixtures.find_questionnaire('DinnerOrderStatic')
+      qr = FHIR.from_contents(questionnaire_response)
+      check_origin_sources(questionnaire.item, qr.item, expected_overrides: ['PBD.2'])
+      check_answer_presence(qr.item, link_ids: ['PBD.1', 'PBD.2', 'LOC.1'])
+      assert(messages.none? { |m| m[:type] == 'error' }, 'QuestionnaireResponse is not correct, see error message(s)')
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/dtr_full_ehr_questionnaire_workflow_group.rb

@@ -5,7 +5,8 @@ require_relative 'dtr_full_ehr_prepopulation_attestation_test'
 require_relative 'dtr_full_ehr_prepopulation_override_attestation_test'
 require_relative 'dtr_full_ehr_rendering_enabled_questions_attestation_test'
 require_relative 'dtr_full_ehr_store_attestation_test'
-require_relative 'dtr_full_ehr_prepopulation_representation_attestation_test'
+require_relative 'dtr_full_ehr_dinner_static_questionnaire_response_conformance_test'
+require_relative 'dtr_full_ehr_dinner_static_questionnaire_response_correctness_test'
 
 module DaVinciDTRTestKit
   class DTRFullEHRStaticDinnerQuestionnaireWorkflowGroup < Inferno::TestGroup
@@ -68,14 +69,23 @@ module DaVinciDTRTestKit
         The tester will attest to the completion of the questionnaire such that
         the results are stored for later use.
       )
+      input :questionnaire_response,
+            type: 'textarea',
+            title: 'Completed QuestionnaireResponse',
+            optional: true,
+            description: %(
+              The QuestionnaireResponse as exported from the EHR after completion of the Questionnaire. IMPORTANT: If
+              you have not yet run the 'Filling Out the Static Questionnaire' group, leave this blank until you have
+              done so. Then, run just the 'Saving the QuestionnaireResponse' group and populate this input.
+            )
       run_as_group
 
       # Test 1: attest QuestionnaireResponse saved
       test from: :dtr_full_ehr_dinner_static_store_attestation
-      # Test 2: validate basic conformance of the QuestionnaireResponse
-      # - not using currently
-      # Test 3: validate workflow-specific details such as pre-population and overrides
-      test from: :dtr_full_ehr_dinner_static_prepopulation_representation_attestation
+      # Test 2: verify basic conformance of the QuestionnaireResponse
+      test from: :dtr_full_ehr_dinner_static_questionnaire_response_conformance
+      # Test 3: check workflow-specific details such as pre-population and overrides
+      test from: :dtr_full_ehr_dinner_static_questionnaire_response_correctness
     end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/dinner_static/dtr_smart_app_dinner_questionnaire_package_request_test.rb

@@ -83,7 +83,7 @@ module DaVinciDTRTestKit
       launch_prompt = if smart_app_launch == 'ehr'
                         %(Launch the DTR SMART App from Inferno by right clicking
                           [this link](#{launch_uri}?iss=#{fhir_base_url}&launch=#{launch_uri})
-                          and selecting or "Open in new window" or "Open in new tab".)
+                          and selecting "Open in new window" or "Open in new tab".)
                       else
                         %(Launch the SMART App from your EHR.)
                       end

data/lib/davinci_dtr_test_kit/client_groups/shared/dtr_questionnaire_response_basic_conformance_test.rb

@@ -1,8 +1,10 @@
 require_relative '../../urls'
+require_relative '../../dtr_questionnaire_response_validation'
 
 module DaVinciDTRTestKit
   class DTRQuestionnaireResponseBasicConformanceTest < Inferno::Test
     include URLs
+    include DTRQuestionnaireResponseValidation
 
     id :dtr_questionnaire_response_basic_conformance
     title 'QuestionnaireResponse is conformant'
@@ -16,13 +18,7 @@ module DaVinciDTRTestKit
       assert request.url == questionnaire_response_url,
              "Request made to wrong URL: #{request.url}. Should instead be to #{questionnaire_response_url}"
 
-      assert_valid_json(request.request_body)
-      questionnaire_response = FHIR.from_contents(request.request_body)
-      assert questionnaire_response.present?, 'Request does not contain a recognized FHIR object'
-      assert_resource_type(:questionnaire_response, resource: questionnaire_response)
-
-      assert_valid_resource(resource: questionnaire_response,
-                            profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-questionnaireresponse|2.0.1')
+      verify_basic_conformance(request.request_body)
     end
   end
 end

data/lib/davinci_dtr_test_kit/client_groups/shared/dtr_questionnaire_response_pre_population_test.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require_relative '../../dtr_questionnaire_response_validation'
+require_relative '../../fixtures'
 
 module DaVinciDTRTestKit
   class DTRQuestionnaireResponsePrePopulationTest < Inferno::Test
@@ -21,11 +24,12 @@ module DaVinciDTRTestKit
     )
 
     run do
-      assert_valid_json(request.request_body)
-      questionnaire_response = FHIR.from_contents(request.request_body)
-      skip_if !questionnaire_response.present?, 'QuestionnaireResponse not received'
-
-      validate_questionnaire_pre_population(questionnaire_response, id)
+      questionnaire_response_json = request.request_body
+      check_is_questionnaire_response(questionnaire_response_json)
+      questionnaire_response = FHIR.from_contents(questionnaire_response_json)
+      questionnaire = Fixtures.questionnaire_for_test(id)
+      response_template = Fixtures.questionnaire_response_for_test(id)
+      validate_questionnaire_pre_population(questionnaire, response_template, questionnaire_response)
     end
   end
 end

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_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.