davinci_dtr_test_kit 0.9.0

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_validation_test.rb

@@ -0,0 +1,49 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormQuestionnaireResponseTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+    id :payer_server_adaptive_response_validation_test
+    title 'Validate that the adaptive response conforms to the Output Parameters profile'
+    # output :questionnaire_response
+    description %(
+      This test validates the conformance of the payer's response to the
+      [DTR Output Parameters](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      endpoint = custom_endpoint.blank? ? '/Questionnaire/$questionnaire-package' : custom_endpoint
+      if initial_adaptive_questionnaire_request.nil?
+        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
+      else
+        resources = []
+        if initial_adaptive_questionnaire_request.is_a?(Array)
+          initial_adaptive_questionnaire_request.each do |_resource|
+            resources.push(fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
+                                                               headers: { 'Content-Type': 'application/json' }))
+          end
+        else
+          resources.push(fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
+                                                             headers: { 'Content-Type': 'application/json' }))
+        end
+      end
+      scratch[:adaptive_responses] = resources
+      assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
+      perform_response_validation_test(
+        resources,
+        :parameters,
+        'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters'
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_request_validation_test.rb

@@ -0,0 +1,61 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormNextRequestTest < Inferno::Test
+    include URLs
+    include DaVinciDTRTestKit::ValidationTest
+    title '[USER INPUT VALIDATION] Next Question request is valid'
+    description %(
+      This test validates the conformance of the client's request to the
+      [SDC Parameters Next Question In](http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+    id :payer_server_next_request_validation
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      if next_question_requests.nil?
+        resources = load_tagged_requests(NEXT_TAG)
+        using_manual_entry = false
+        skip_if resources.nil?, 'No plain resources to validate.'
+        json_resources = resources.map { |r| JSON.parse(r.request_body) }
+      else
+        resources = next_question_requests
+        json_resources = JSON.parse(resources)
+        using_manual_entry = true
+      end
+      skip_if json_resources.nil?, 'No json resources to validate.'
+      if json_resources.any? { |r| r['resourceType'] == 'QuestionnaireResponse' }
+        perform_request_validation_test(
+          resources,
+          :questionnaireResponse,
+          'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt',
+          next_url,
+          using_manual_entry
+        )
+      elsif json_resources.any? { |r| r['resourceType'] == 'Parameters' }
+        perform_request_validation_test(
+          resources,
+          :parameters,
+          'http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in',
+          next_url,
+          using_manual_entry
+        )
+      else
+        raise new Inferno::Exceptions::AssertionException.new "Resource does not conform to the either
+         accepted profiles: http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt
+         or http://hl7.org/fhir/uv/sdc/StructureDefinition/parameters-questionnaire-next-question-in"
+      end
+    rescue Inferno::Exceptions::AssertionException => e
+      msg = e.message.to_s.strip
+      skip msg
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_response_complete_test.rb

@@ -0,0 +1,17 @@
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormCompleteTest < Inferno::Test
+    id :payer_server_adaptive_completion_test
+    title 'Adaptive questionnaire was completed.'
+    description %(
+      This test validates that in the sequence of adaptive responses, one includes a "completed" status.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      assert !scratch[:next_responses].nil?, 'No resources to validate.'
+      assert scratch[:next_responses].any? { |r|
+               JSON.parse(r.response_body)['status'] == 'completed'
+             }, 'Next request sequence did not result in a completed questionnaire.'
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_response_validation_test.rb

@@ -0,0 +1,43 @@
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerAdaptiveFormNextResponseTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+    id :payer_server_next_response_validation_test
+    title 'Inferno sends payer server a request for subsequent adaptive forms - validate the responses'
+    description %(
+      This test validates the conformance of the payer's response to the
+      [SDC Questionnaire Response](http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse)
+      structure.
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Static', 'Performing only static flow tests - only one flow is required.'
+      if next_question_requests.nil?
+        resources = load_tagged_requests(NEXT_TAG)
+      else
+        json_requests = JSON.parse(next_question_requests)
+        resources = json_requests.map do |resource|
+          fhir_operation("#{url}/Questionnaire/$next-question",
+                         body: resource,
+                         headers: { 'Content-Type': 'application/json' })
+        end
+      end
+      assert !resources.nil?, 'No resources to validate.'
+      scratch[:next_responses] = resources
+      perform_response_validation_test(
+        resources,
+        :questionnaireResponse,
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse'
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_static_group.rb

@@ -0,0 +1,51 @@
+require_relative 'static_form_request_test'
+require_relative 'static_form_request_validation_test'
+require_relative 'static_form_response_validation_test'
+require_relative 'static_form_libraries_test'
+require_relative 'static_form_questionnaire_extensions_test'
+require_relative 'static_form_questionnaire_expressions_test'
+
+module DaVinciDTRTestKit
+  class DTRPayerServerQuestionnairePackageGroup < Inferno::TestGroup
+    title 'Static Questionnaire Package Retrieval'
+    short_description 'Verify support for the payer server capabilities required to provide
+    appropriate questionnaire packages upon request.'
+    description %(
+    ## Background
+
+    The DTR Payer Server sequence verifies that the system under test is
+    able to provide correct responses for questionnaire package queries. These queries
+    must contain resources conforming to the questionnaire-package as
+    specified in the DTR v2.0.1 Implementation Guide.
+
+    ## Testing Work Flow Options
+
+      - Enter the `FHIR Server Base Url` and `Access Token` if you are connecting a client that will
+       provide inferno with requests to be tested and sent to the server under test.
+       These inputs must align with the configuration of the DTR client being used to provide requests.
+
+      - Enter the `Initial Static Questionnaire Request`, in addition to the
+      `FHIR Server Base Url` pointing to the payer server,
+      to provide the json requests manually, rather than relying on a DTR client.
+          )
+    id :payer_server_static_package
+    run_as_group
+
+    input :initial_static_questionnaire_request,
+          optional: true,
+          title: 'Initial Static Questionnaire Request',
+          description: 'Manual Flow',
+          type: 'textarea'
+
+    input_order :retrieval_method,
+                :url,
+                :initial_static_questionnaire_request
+
+    test from: :dtr_v201_payer_static_questionnaire_request_test, receives_request: :statice_questionnaire_request
+    test from: :dtr_v201_payer_static_form_request_validation_test
+    test from: :dtr_v201_payer_static_form_response_test
+    test from: :dtr_v201_payer_static_form_libraries_test
+    test from: :dtr_v201_payer_static_form_extensions_test
+    test from: :dtr_v201_payer_static_form_expressions_test
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_libraries_test.rb

@@ -0,0 +1,19 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormLibrariesTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_static_form_libraries_test
+    title 'Parameters contain libraries necessary for pre-population'
+    description %(
+      Inferno check that the payer response contains no duplicate library names
+       and that libraries contain cql and elm data.
+    )
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
+      check_libraries(scratch[:questionnaire_bundle])
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_expressions_test.rb

@@ -0,0 +1,20 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormExpressionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_static_form_expressions_test
+    title 'Questionnaire(s) contains items with expressions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate expressions and that expressions are
+       written in cql.
+    )
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
+      questionnaire_items_test(scratch[:questionnaire_bundle], final_cql_test: true)
+      scratch[:questionnaire_bundle] = nil
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_questionnaire_extensions_test.rb

@@ -0,0 +1,19 @@
+require_relative '../cql_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormExtensionsTest < Inferno::Test
+    include DaVinciDTRTestKit::CQLTest
+
+    id :dtr_v201_payer_static_form_extensions_test
+    title 'Questionnaire(s) contains extensions necessary for pre-population'
+    description %(
+      Inferno checks that the payer server response has appropriate extensions and references to libraries within
+      those extensions.
+    )
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+      skip_if scratch[:questionnaire_bundle].nil?, 'No questionnaire bundle returned.'
+      questionnaire_extensions_test(scratch[:questionnaire_bundle])
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_request_test.rb

@@ -0,0 +1,33 @@
+require_relative '../urls'
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class StaticRFormRequestTest < Inferno::Test
+    include URLs
+    title 'Validate the questionnaires returned by the payer server'
+    description %(
+      Inferno will validate questionnaires returned by the payer server.
+    )
+    id :dtr_v201_payer_static_questionnaire_request_test
+    config options: { accepts_multiple_requests: false }
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+      pass_if !initial_static_questionnaire_request.nil?,
+              'Proceeding with manually provided resources.'
+      skip_if access_token.nil?, 'Please provide an access token or all request resources as inputs.'
+      wait(
+        identifier: access_token,
+        message: %(
+          **Static Form Testing**
+
+          Invoke the DTR Questionnaire Package operation by sending a POST request to
+
+          `#{questionnaire_package_url}`
+
+          A set of questionnaire packages generated by Inferno will be returned. Each of the following tests
+          will validate all resources, marking messages in the order they are received.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_request_validation_test.rb

@@ -0,0 +1,46 @@
+require_relative '../urls'
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormRequestValidationTest < Inferno::Test
+    include DaVinciDTRTestKit::ValidationTest
+    include URLs
+    id :dtr_v201_payer_static_form_request_validation_test
+    title '[USER INPUT VALIDATION] Client sends payer server a request for a static form'
+    description %(
+      Inferno will validate that the request to the payer server conforms to the
+       [Input Parameters profile](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters).
+
+       It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+       values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+       to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system
+       are not found in the valueset.
+
+       This test may process multiple resources, labeling messages with the corresponding tested resources
+       in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+      if initial_static_questionnaire_request.nil?
+        using_manual_entry = false
+        skip_if access_token.nil?, 'No access token provided - required for client flow.'
+        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
+        skip_if resources.nil?, 'No request resource received from the client.'
+        perform_request_validation_test(
+          resources,
+          :parameters,
+          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters',
+          questionnaire_package_url,
+          using_manual_entry
+        )
+      else
+        skip_if initial_static_questionnaire_request.nil?, 'No request resource was provided - required for manual flow'
+        request = FHIR.from_contents(initial_static_questionnaire_request)
+        assert_valid_resource(resource: request, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-input-parameters')
+      end
+    rescue Inferno::Exceptions::AssertionException => e
+      msg = e.message.to_s.strip
+      skip msg
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_response_validation_test.rb

@@ -0,0 +1,50 @@
+require_relative '../urls'
+require_relative '../validation_test'
+module DaVinciDTRTestKit
+  class PayerStaticFormResponseTest < Inferno::Test
+    include URLs
+    include DaVinciDTRTestKit::ValidationTest
+    id :dtr_v201_payer_static_form_response_test
+    title 'Validate that the static response conforms to the Output Parameters profile'
+    description %(
+      Inferno will validate that the payer server response conforms to the
+       [Output Parameters profile](http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters).
+
+      It verifies the presence of mandatory elements and that elements with required bindings contain appropriate
+      values. CodeableConcept element bindings will fail if none of their codings have a code/system belonging
+      to the bound ValueSet. Quantity, Coding, and code element bindings will fail if their code/system are not found in
+      the valueset.
+
+      This test may process multiple resources, labeling messages with the corresponding tested resources
+      in the order that they were received.
+    )
+
+    run do
+      skip_if retrieval_method == 'Adaptive', 'Performing only adaptive flow tests - only one flow is required.'
+
+      if initial_static_questionnaire_request.nil?
+        skip_if access_token.nil?, 'No access token provided - required for client flow.'
+        resources = load_tagged_requests(QUESTIONNAIRE_TAG)
+        skip_if resources.nil?, 'No request resource received from the client.'
+        scratch[:questionnaire_bundle] = resources
+        perform_response_validation_test(
+          resources,
+          :parameters,
+          'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters'
+        )
+      else
+        FHIR.from_contents(initial_static_questionnaire_request)
+        fhir_operation("#{url}/Questionnaire/$questionnaire-package",
+                       body: JSON.parse(initial_static_questionnaire_request),
+                       headers: { 'Content-Type': 'application/json' })
+        scratch[:questionnaire_bundle] = resource
+
+        assert_response_status(200)
+        assert_resource_type(:parameters)
+        questionnaire_bundle = resource.parameter.find { |param| param.name == 'return' }&.resource
+        assert questionnaire_bundle, 'No questionnaire bundle found in the response'
+        assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle')
+      end
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/tags.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  QUESTIONNAIRE_TAG = 'payer_server_questionnaire_package'
+  NEXT_TAG = 'payer_server_adaptive_questionnaire_package'
+  QUESTIONNAIRE_PACKAGE_TAG = 'dtr_questionnaire_package'
+  SMART_APP_EHR_REQUEST_TAG = 'dtr_smart_app_ehr_request'
+end

data/lib/davinci_dtr_test_kit/urls.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  TOKEN_PATH = '/mock_auth/token'
+  QUESTIONNAIRE_PACKAGE_PATH = '/fhir/Questionnaire/$questionnaire-package'
+  NEXT_PATH = '/fhir/Questionnaire/$next-question'
+  QUESTIONNAIRE_RESPONSE_PATH = '/fhir/QuestionnaireResponse'
+  RESUME_PASS_PATH = '/resume_pass'
+  RESUME_FAIL_PATH = '/resume_fail'
+  FHIR_RESOURCE_PATH = '/fhir/:resource/:id'
+  FHIR_SEARCH_PATH = '/fhir/:resource'
+
+  module URLs
+    def base_url
+      @base_url ||= "#{Inferno::Application['base_url']}/custom/#{suite_id}"
+    end
+
+    def token_url
+      @token_url ||= base_url + TOKEN_PATH
+    end
+
+    def questionnaire_package_url
+      @questionnaire_package_url ||= base_url + QUESTIONNAIRE_PACKAGE_PATH
+    end
+
+    def next_url
+      @next_url ||= base_url + NEXT_PATH
+    end
+
+    def questionnaire_response_url
+      @questionnaire_response_url ||= base_url + QUESTIONNAIRE_RESPONSE_PATH
+    end
+
+    def fhir_base_url
+      @fhir_base_url ||= "#{base_url}/fhir"
+    end
+
+    def resume_pass_url
+      @resume_pass_url ||= base_url + RESUME_PASS_PATH
+    end
+
+    def resume_fail_url
+      @resume_fail_url ||= base_url + RESUME_FAIL_PATH
+    end
+
+    def suite_id
+      self.class.suite.id
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/validation_test.rb

@@ -0,0 +1,72 @@
+module DaVinciDTRTestKit
+  module ValidationTest
+    def tests_failed
+      @tests_failed ||= {}
+    end
+
+    def validate_resource(fhir_resource, resource_type, profile_url, index)
+      assert fhir_resource.present?, 'Resource does not contain a recognized FHIR object'
+      begin
+        assert_resource_type(resource_type, resource: fhir_resource)
+        assert_valid_resource(resource: fhir_resource,
+                              profile_url:)
+      rescue StandardError => e
+        messages.each do |message|
+          message[:message].prepend("[Resource #{index + 1}] ")
+        end
+        if tests_failed[profile_url].blank?
+          tests_failed[profile_url] = [e]
+        else
+          tests_failed[profile_url] << e
+        end
+        return false
+      end
+      true
+    end
+
+    def perform_request_validation_test(
+      resources,
+      resource_type,
+      profile_url,
+      resource_url,
+      using_manual_entry
+    )
+      omit_if resources.blank?,
+              "No #{resource_type} resources provided so the #{profile_url} profile does not apply"
+      resources = JSON.parse(resources) if using_manual_entry
+      resources = [resources] unless resources.is_a?(Array)
+      resources.each_with_index do |resource, index|
+        if using_manual_entry
+          assert_valid_json(resource.to_json)
+          fhir_resource = FHIR.from_contents(resource.to_json)
+        else
+          assert resource.url == resource_url,
+                 "Request made to wrong URL: #{resource.request[:url]}. Should instead be to #{resource_url}"
+          assert_valid_json(resource.request[:body])
+          fhir_resource = FHIR.from_contents(resource.request[:body])
+        end
+        validate_resource(fhir_resource, resource_type, profile_url, index)
+      end
+      return if tests_failed[profile_url].blank?
+
+      raise tests_failed[profile_url][0]
+    end
+
+    def perform_response_validation_test(
+      resources,
+      resource_type,
+      profile_url
+    )
+      omit_if resources.blank?,
+              "No #{resource_type} resources provided so the #{profile_url} profile does not apply"
+      resources.each_with_index do |resource, index|
+        fhir_resource = FHIR.from_contents(resource.response[:body])
+        assert_response_status([200, 202], request: resource, response: resource.response)
+        validate_resource(fhir_resource, resource_type, profile_url, index)
+      end
+      return if tests_failed[profile_url].blank?
+
+      raise tests_failed[profile_url][0]
+    end
+  end
+end

data/lib/davinci_dtr_test_kit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DaVinciDTRTestKit
+  VERSION = '0.9.0'.freeze
+end

data/lib/davinci_dtr_test_kit.rb

@@ -0,0 +1,4 @@
+require_relative 'davinci_dtr_test_kit/dtr_payer_server_suite'
+require_relative 'davinci_dtr_test_kit/dtr_smart_app_suite'
+# require_relative 'davinci_dtr_test_kit/dtr_full_ehr_suite'
+# require_relative 'davinci_dtr_test_kit/dtr_light_ehr_suite'