davinci_dtr_test_kit 0.13.0 → 0.14.1

data/lib/davinci_dtr_test_kit/client_groups/resp_assist_device/dtr_resp_questionnaire_package_request_test.rb

@@ -10,6 +10,7 @@ module DaVinciDTRTestKit
       Inferno will wait for a DTR questionnaire package request from the client. Upon receipt, Inferno will generate and
       send a response.
     )
+    config options: { accepts_multiple_requests: true }
     input :smart_app_launch,
           type: 'radio',
           title: 'SMART App Launch',
@@ -20,38 +21,34 @@ module DaVinciDTRTestKit
     input :launch_uri,
           optional: true,
           description: 'Required if "Launch from Inferno" is selected'
-    input :smart_patient_id,
+    input :resp_smart_patient_id,
           optional: true,
           title: 'SMART App Launch Patient ID (Respiratory Assist Device)',
           type: 'text',
           description: %(
-            Patient instance `id` to be provided by Inferno as the `patient` as a part of the SMART App
-            Launch.
+            Patient instance ID to be provided by Inferno as the patient as a part of the SMART App Launch.
           ),
           default: 'pat015'
-    input :smart_fhir_context,
+    input :resp_smart_fhir_context,
           optional: true,
           title: 'SMART App Launch fhirContext (Respiratory Assist Device)',
           type: 'textarea',
           description: %(
-            References to be provided by Inferno as the `fhirContext` as a part of the SMART App
+            References to be provided by Inferno as the fhirContext as a part of the SMART App
             Launch. These references help determine the behavior of the app. Referenced instances
             may be provided in the "EHR-available resources" input.
           ),
           default: JSON.pretty_generate([{ reference: 'Coverage/cov015' },
                                          { reference: 'DeviceRequest/devreqe0470' }])
-    input :ehr_bundle,
+    input :resp_ehr_bundle,
           optional: true,
           title: 'EHR-available resources (Respiratory Assist Device)',
           type: 'textarea',
           description: %(
             Resources available from the EHR needed to drive the respiratory assist device workflow.
-            Formatted as a FHIR bundle that contains resources, each with an `id` property populated. Each
-            instance present will be available for retrieval from Inferno at the endpoint
-
-            ```
-            [fhir-base]/[resource type]/[instance id]
-            ```
+            Formatted as a FHIR bundle that contains resources, each with an ID property populated. Each
+            instance present will be available for retrieval from Inferno at the endpoint:
+            <fhir-base>/<resource type>/<instance id>
           )
 
     def example_client_jwt_payload_part
@@ -61,19 +58,19 @@ module DaVinciDTRTestKit
     run do
       # validate relevant inputs and provide warnings if they are bad
       warning do
-        if smart_fhir_context
-          assert_valid_json(smart_fhir_context,
+        if resp_smart_fhir_context
+          assert_valid_json(resp_smart_fhir_context,
                             'The **SMART App Launch fhirContext** input is not valid JSON, so it will not be included in
                             the access token response.')
         end
       end
 
       warning do
-        if ehr_bundle
-          assert_valid_json(ehr_bundle,
+        if resp_ehr_bundle
+          assert_valid_json(resp_ehr_bundle,
                             'The **EHR-available resources** input is not valid JSON, so no tester-specified instances
                               will be available to access from Inferno.')
-          assert(FHIR.from_contents(ehr_bundle).is_a?(FHIR::Bundle),
+          assert(FHIR.from_contents(resp_ehr_bundle).is_a?(FHIR::Bundle),
                  'The **EHR-available resources** input does not contain a FHIR Bundle, so no tester-specified instances
                  will be available to access from Inferno.')
         end
@@ -117,7 +114,7 @@ module DaVinciDTRTestKit
           an `Authorization` header with value:
 
           ```
-          Bearer eyJhbGcmOiJub25lIn0.#{example_client_jwt_payload_part}.
+          Bearer eyJhbGciOiJub25lIn0.#{example_client_jwt_payload_part}.
           ```
 
           ### Continuing the Tests

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

@@ -14,11 +14,15 @@ module DaVinciDTRTestKit
       to the DTR Questionnaire Response resource profile.
     )
 
+    def profile_url
+      config.options[:qr_profile_url]
+    end
+
     run do
       assert request.url == questionnaire_response_url,
              "Request made to wrong URL: #{request.url}. Should instead be to #{questionnaire_response_url}"
 
-      verify_basic_conformance(request.request_body)
+      verify_basic_conformance(request.request_body, profile_url)
     end
   end
 end

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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative '../../dtr_questionnaire_response_validation'
 require_relative '../../fixtures'
 
@@ -27,9 +25,18 @@ module DaVinciDTRTestKit
       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)
+      if config.options[:adaptive]
+        questionnaire = questionnaire_response.contained.find { |res| res.resourceType == 'Questionnaire' }
+        assert questionnaire, 'Adaptive QuestionnaireResponse must have a contained Questionnaire resource.'
+        check_origin_sources(questionnaire.item, questionnaire_response.item, expected_overrides: ['PBD.2'])
+        required_link_ids = extract_required_link_ids(questionnaire.item)
+        check_answer_presence(questionnaire_response.item, required_link_ids)
+        assert(messages.none? { |m| m[:type] == 'error' }, 'QuestionnaireResponse is not correct, see error message(s)')
+      else
+        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
 end

data/lib/davinci_dtr_test_kit/client_groups/{dinner_static → smart_app}/dtr_smart_app_prepopulation_attestation_test.rb

@@ -1,27 +1,27 @@
+require 'securerandom'
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppStaticDinnerPrepopulationAttestationTest < Inferno::Test
+  class DTRSmartAppPrepopulationAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_smart_app_dinner_static_rendering_prepopulation_attestation
+    id :dtr_smart_app_prepopulation_attestation
     title 'Check that the client pre-populates the questionnaire (Attestation)'
     description %(
       Validate that pre-population of patient name information occurs as expected.
     )
-    input :client_id
-
     run do
+      random_id = SecureRandom.uuid
       wait(
-        identifier: client_id,
+        identifier: random_id,
         message: %(
           I attest that the client application pre-populates the following questions with the respective values:
           - Last Name: Oster
           - First Name: William
 
-          [Click here](#{resume_pass_url}?client_id=#{client_id}) if the above statement is **true**.
+          [Click here](#{resume_pass_url}?client_id=#{random_id}) if the above statement is **true**.
 
-          [Click here](#{resume_fail_url}?client_id=#{client_id}) if the above statement is **false**.
+          [Click here](#{resume_fail_url}?client_id=#{random_id}) if the above statement is **false**.
         )
       )
     end

data/lib/davinci_dtr_test_kit/client_groups/{dinner_static → smart_app}/dtr_smart_app_prepopulation_override_attestation_test.rb

@@ -1,28 +1,29 @@
+require 'securerandom'
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppStaticDinnerPrepopulationOverrideAttestationTest < Inferno::Test
+  class DTRSmartAppPrepopulationOverrideAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_smart_app_dinner_static_prepopulation_override_attestation
+    id :dtr_smart_app_prepopulation_override_attestation
     title 'Validate the user can override pre-populated data (Attestation)'
     description %(
       Validate that the user can edit a pre-populated item and replace it with another value.
     )
-    input :client_id
 
     run do
+      random_id = SecureRandom.uuid
       wait(
-        identifier: client_id,
+        identifier: random_id,
         message: %(
           I attest that
 
           1. The client pre-populated an answer for question 'Location'.
           2. I have changed the answer to a different value.
 
-          [Click here](#{resume_pass_url}?client_id=#{client_id}) if the above statement is **true**.
+          [Click here](#{resume_pass_url}?client_id=#{random_id}) if the above statement is **true**.
 
-          [Click here](#{resume_fail_url}?client_id=#{client_id}) if the above statement is **false**.
+          [Click here](#{resume_fail_url}?client_id=#{random_id}) if the above statement is **false**.
         )
       )
     end

data/lib/davinci_dtr_test_kit/client_groups/{dinner_static → smart_app}/dtr_smart_app_questionnaire_response_save_test.rb

@@ -1,30 +1,40 @@
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppStaticDinnerQuestionnaireResponseSaveTest < Inferno::Test
+  class DTRSmartAppQuestionnaireResponseSaveTest < Inferno::Test
     include URLs
 
-    id :dtr_smart_app_static_dinner_questionnaire_response_save
+    id :dtr_smart_app_questionnaire_response_save
     title 'Save the QuestionnaireResponse after completing it'
     description %(
       Inferno, acting as the EHR, will wait for a request to save the QuestionnaireResponse from the client.
     )
     input :client_id
 
-    run do
-      wait(
-        identifier: client_id,
-        message: %(
+    def prompt
+      if config.options[:adaptive]
+        'Store the completed questionnaire back into the EHR.'
+      else
+        <<~DESCRIPTION
           Complete the questionnaire, leaving the following items unmodified, because a subsequent test will expect
           their pre-populated values:
 
           - First Name
           - Last Name
+        DESCRIPTION
+      end
+    end
+
+    run do
+      wait(
+        identifier: client_id,
+        message: <<~MESSAGE
+          #{prompt}
 
           Inferno will wait for a POST request at:
 
           `#{questionnaire_response_url}`
-        )
+        MESSAGE
       )
     end
   end

data/lib/davinci_dtr_test_kit/client_groups/{dinner_static → smart_app}/dtr_smart_app_rendering_enabled_questions_attestation_test.rb

@@ -1,28 +1,28 @@
+require 'securerandom'
 require_relative '../../urls'
 
 module DaVinciDTRTestKit
-  class DTRSmartAppStaticDinnerRenderingAttestationTest < Inferno::Test
+  class DTRSmartAppRenderingEnabledQuestionsAttestationTest < Inferno::Test
     include URLs
 
-    id :dtr_smart_app_dinner_static_rendering_enabledQs_attestation
+    id :dtr_smart_app_rendering_enabled_questions_attestation
     title 'Check that the client renders enabled questions appropriately (Attestation)'
     description %(
       Validate that the rendering of the questionnaire includes only the "What would you like on..."
       question appropriate for the dinner selection, if made.
     )
-    input :client_id
-
     run do
+      random_id = SecureRandom.uuid
       wait(
-        identifier: client_id,
+        identifier: random_id,
         message: %(
           I attest that the client application does not display any "What would you like on..."
           questions until I have selected a dinner choice and then only displays the
           "What would you like on..." question relevant for the dinner request:
 
-          [Click here](#{resume_pass_url}?client_id=#{client_id}) if the above statement is **true**.
+          [Click here](#{resume_pass_url}?client_id=#{random_id}) if the above statement is **true**.
 
-          [Click here](#{resume_fail_url}?client_id=#{client_id}) if the above statement is **false**.
+          [Click here](#{resume_fail_url}?client_id=#{random_id}) if the above statement is **false**.
         )
       )
     end

data/lib/davinci_dtr_test_kit/client_groups/smart_app/dtr_smart_app_saving_questionnaire_response_group.rb

@@ -0,0 +1,27 @@
+require_relative 'dtr_smart_app_questionnaire_response_save_test'
+require_relative '../shared/dtr_questionnaire_response_basic_conformance_test'
+require_relative '../shared/dtr_questionnaire_response_pre_population_test'
+
+module DaVinciDTRTestKit
+  class DTRSmartAppSavingQuestionnaireResponseGroup < Inferno::TestGroup
+    id :dtr_smart_app_saving_questionnaire_response
+    title 'Saving the QuestionnaireResponse'
+    description %(
+      The tester will complete the questionnaire such that a QuestionnaireResponse is stored
+      back into Inferno's EHR endpoint. The stored QuestionnaireResponse will be evaluated for
+      conformance, completeness, and correct indicators on pre-populated and manually-overriden
+      items.
+    )
+    run_as_group
+
+    # Test 1: wait for a QuestionnaireResponse
+    test from: :dtr_smart_app_questionnaire_response_save,
+         receives_request: :questionnaire_response_save
+    # Test 2: validate basic conformance of the QuestionnaireResponse
+    test from: :dtr_questionnaire_response_basic_conformance,
+         uses_request: :questionnaire_response_save
+    # Test 3: validate workflow-specific details such as pre-population and overrides
+    test from: :dtr_questionnaire_response_pre_population,
+         uses_request: :questionnaire_response_save
+  end
+end

data/lib/davinci_dtr_test_kit/cql_test.rb

@@ -48,53 +48,10 @@ module DaVinciDTRTestKit
       extension_presence.each_key { |k| extension_presence[k] = false }
     end
 
-    def evaluate_responses_extensions(resource)
-      found_questionnaire = false
-      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
-      found_questionnaire
-    end
-
-    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'
-
-        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
-      found_questionnaire
-    end
-
-    # extensions
-    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
-        found_questionnaire = evaluate_responses_extensions(resource)
-      elsif resource.resourceType == 'Parameters'
-        found_questionnaire = evaluate_parameters_extensions(resource)
-      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.'
@@ -140,53 +97,11 @@ module DaVinciDTRTestKit
       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'
+    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) }
 
-          # 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.'
@@ -281,12 +196,12 @@ module DaVinciDTRTestKit
       assert misformatted_expressions.compact.to_set.empty?, 'Expression in questionnaire misformatted.'
     end
 
-    def evaluate_library(entry, lib_index)
+    def evaluate_library(library)
       found_cql = found_elm = false
-      entry.resource.content.each do |content|
+      library.content.each do |content|
         if content.data.nil?
           messages << { type: 'info',
-                        message: format_markdown("[library #{lib_index + 1}] content element included no data.") }
+                        message: format_markdown("[library #{library.url}] content element included no data.") }
         end
         if content.contentType == 'text/cql'
           found_cql = true
@@ -294,42 +209,30 @@ module DaVinciDTRTestKit
           found_elm = true
         else
           messages << { type: 'info',
-                        message: format_markdown("[library #{lib_index + 1}] has non-cql/elm content.") }
+                        message: format_markdown("[library #{library.url}] has non-cql/elm content.") }
           true
         end
-        next unless library_names.include? entry.resource.name
+        next unless library_names.include? library.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.") }
+        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 #{lib_index + 1}] does not include CQL."
-      assert found_elm, "[library #{lib_index + 1}] does not include ELM."
+      assert found_cql, "[library #{library.url}] does not include CQL."
+      assert found_elm, "[library #{library.url}] 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.'
-      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
-          library_urls.add(entry.resource.url) unless entry.resource.url.nil?
-          evaluate_library(entry, index)
-          library_names.add(entry.resource.name)
-        end
-        assert found_libraries, 'No Libraries found.'
+    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
@@ -405,28 +308,22 @@ 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
+    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 process_response(response)
-      if response.instance_of?(FHIR::Parameters) || response.instance_of?(FHIR::QuestionnaireResponse)
-        return response
-      elsif response.instance_of? Array
-        return q_responses(response)
-      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