davinci_crd_test_kit 0.13.0 → 0.14.1

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/coverage_info_reason_test.rb

@@ -0,0 +1,108 @@
+module DaVinciCRDTestKit
+  module V221
+    # Users of this test need to set config options for coverage_code, reason_code, and optionally require_reason_text
+    class CoverageInfoReasonTest < Inferno::Test
+      id :crd_v221_coverage_info_reason
+      title 'Coverage Information responses have the expected coverage and reason codes'
+
+      description <<~DESCRIPTION
+        This test verifies that the Coverage Information responses received contain Coverage Information extensions
+        with the expected coverage and reason codes.
+      DESCRIPTION
+
+      input :coverage_info
+
+      COVERAGE_INFO_EXTENSION_URL =
+        'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/ext-coverage-information'.freeze
+
+      run do
+        coverage_info_actions = JSON.parse(coverage_info)
+
+        skip_if coverage_info_actions.blank?, 'No Coverage Information system actions received'
+
+        coverage_info_actions.each_with_index do |action, index|
+          coverage_info_extensions(action['resource']).each do |extension|
+            unless expected_coverage? extension
+              coverage_code = coverage_extension_value(extension)
+              add_message(
+                'error',
+                "Coverage should be `#{expected_coverage_code}`, but found `#{coverage_code}` in action ##{index + 1}"
+              )
+            end
+
+            unless expected_reason? extension
+              reason_code =
+                reason_extension_values(extension)
+                  &.map { |reason| "`#{reason}`" }
+                  &.join(', ') || 'no reason'
+              add_message(
+                'error',
+                "Coverage reason should be `#{expected_reason_code}`, but found #{reason_code} in action ##{index + 1}"
+              )
+
+              next
+            end
+
+            next unless require_reason_text?
+            next if reason_text?(extension)
+
+            add_message(
+              'error',
+              "`#{expected_reason_code}` coverage reason contains no additional details in `text` field " \
+              "in action ##{index + 1}"
+            )
+          end
+        end
+
+        assert_no_error_messages(
+          "Not all coverage info extensions had `#{expected_coverage_code}` coverage " \
+          "with a reason of `#{expected_reason_code}`"
+        )
+      end
+
+      def coverage_info_extensions(resource)
+        resource['extension'].select { |extension| extension['url'] == COVERAGE_INFO_EXTENSION_URL }
+      end
+
+      def coverage_extension_value(coverage_info_extension)
+        coverage_info_extension['extension']
+          .find { |extension| extension['url'] == 'covered' }
+          &.dig('valueCode')
+      end
+
+      def expected_coverage?(coverage_info_extension)
+        coverage_extension_value(coverage_info_extension) == expected_coverage_code
+      end
+
+      def reason_extension_values(coverage_info_extension)
+        coverage_info_extension['extension']
+          .find { |extension| extension['url'] == 'reason' }
+          &.dig('valueCodeableConcept', 'coding')
+          &.map { |coding| coding['code'] }
+      end
+
+      def expected_reason?(coverage_info_extension)
+        reason_extension_values(coverage_info_extension)&.include? expected_reason_code
+      end
+
+      def reason_text?(coverage_info_extension)
+        coverage_info_extension['extension']
+          .find { |extension| extension['url'] == 'reason' }
+          &.dig('valueCodeableConcept', 'text')
+          &.present?
+      end
+
+      def expected_coverage_code
+        config.options[:expected_coverage_code]
+      end
+
+      def expected_reason_code
+        config.options[:expected_reason_code]
+      end
+
+      def require_reason_text?
+        config.options[:require_reason_text] || false
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/coverage_not_found_group.rb

@@ -0,0 +1,116 @@
+require_relative '../interaction/server_invoke_hook_single_request_test'
+require_relative 'coverage_info_reason_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class CoverageNotFoundGroup < Inferno::TestGroup
+      title 'Coverage Not Found'
+      id :crd_v221_server_coverage_not_found_group
+      description %(
+        This group of tests allows the system to demonstrate its ability to respond to a CRD Hook invocation
+        with a `not-covered` coverage determination when the patient can be resolved but coverage cannot be found
+        or cannot be resolved to a single coverage.
+
+        For these tests, provide a hook request body that represents a resolvable patient for whom the CRD Server
+        cannot find coverage or cannot resolve to a single coverage. The tests then verify that a Coverage
+        Information systemAction is received with `not-covered` coverage for `coverage-not-found` reason.
+      )
+
+      config options: { hook_name: COVERAGE_NOT_FOUND_TAG }
+      run_as_group
+
+      group do
+        title 'Interaction'
+
+        test from: :crd_v221_server_invoke_hook_single_request_test,
+             title: 'Inferno invokes the selected hook to elicit coverage not found response',
+             description: <<~DESCRIPTION,
+               This test initiates a POST request to a specified CDS Service using the JSON body provided
+               by the user. The request body should represent a resolvable patient for whom coverage cannot be
+               found or cannot be resolved to a single coverage.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 service_ids: {
+                   name: :coverage_not_found_service_ids,
+                   title: 'Service id to use for the "Coverage Not Found" test',
+                   description: %(
+                     If blank, Inferno will attempt to infer the service id to use by finding a service entry
+                     in the Discovery response for the hook indicated in the provided request body. If it
+                     cannot be inferred, the tests will be skipped.
+                   )
+                 },
+                 service_request_bodies: {
+                   name: :coverage_not_found_request_body,
+                   title: 'Request body to use for the "Coverage Not Found" test',
+                   description: %(
+                     Provide a single JSON request body to submit for the hook invocation. The type of hook
+                     invoked will be inferred based on the `hook` element in the request. The body should be
+                     constructed so that it represents a resolvable patient for whom coverage cannot be found.
+                   )
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Requests'
+        simulation_verification
+
+        test from: :crd_v221_service_request_required_fields_validation,
+             config: {
+               outputs: {
+                 contexts: {
+                   name: :coverage_not_found_contexts
+                 }
+               }
+             }
+        test from: :crd_v221_service_request_context_validation,
+             config: {
+               inputs: {
+                 contexts: {
+                   name: :coverage_not_found_contexts
+                 },
+                 request_body: {
+                   name: :coverage_not_found_request_body
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Responses'
+
+        test from: :crd_v221_service_response_validation
+        test from: :crd_v221_coverage_info_system_action_validation,
+             config: {
+               outputs: {
+                 coverage_info: {
+                   name: :coverage_not_found_coverage_info
+                 }
+               }
+             }
+        test from: :crd_v221_coverage_info_reason,
+             title: 'Coverage Information responses have not-covered coverage for coverage-not-found reason',
+             description: <<~DESCRIPTION,
+               This test verifies that the Coverage Information responses received contain Coverage Information
+               extensions with `not-covered` coverage and a `coverage-not-found` reason.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 coverage_info: {
+                   name: :coverage_not_found_coverage_info
+                 }
+               },
+               options: {
+                 expected_coverage_code: 'not-covered',
+                 expected_reason_code: 'coverage-not-found'
+               }
+             },
+             verifies_requirements: [
+               'hl7.fhir.us.davinci-crd_2.2.1@resp-45'
+             ]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/no_active_coverage_group.rb

@@ -0,0 +1,115 @@
+require_relative '../interaction/server_invoke_hook_single_request_test'
+require_relative 'coverage_info_reason_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class NoActiveCoverageGroup < Inferno::TestGroup
+      title 'No Active Coverage'
+      id :crd_v221_server_no_active_coverage_group
+      description %(
+        This group of tests allows the system to demonstrate its ability to respond to a CRD Hook invocation
+        with a `not-covered` coverage determination when the patient can be resolved but does not have active
+        coverage.
+
+        For these tests, provide a hook request body that represents a resolvable patient without active
+        coverage. The tests then verify that a Coverage Information systemAction is received with `not-covered`
+        coverage for `no-active-coverage` reason.
+      )
+
+      config options: { hook_name: NO_ACTIVE_COVERAGE_TAG }
+      run_as_group
+
+      group do
+        title 'Interaction'
+
+        test from: :crd_v221_server_invoke_hook_single_request_test,
+             title: 'Inferno invokes the selected hook to elicit no active coverage response',
+             description: <<~DESCRIPTION,
+               This test initiates a POST request to a specified CDS Service using the JSON body provided
+               by the user. The request body should represent a resolvable patient without active coverage.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 service_ids: {
+                   name: :no_active_coverage_service_ids,
+                   title: 'Service id to use for the "No Active Coverage" test',
+                   description: %(
+                     If blank, Inferno will attempt to infer the service id to use by finding a service entry
+                     in the Discovery response for the hook indicated in the provided request body. If it
+                     cannot be inferred, the tests will be skipped.
+                   )
+                 },
+                 service_request_bodies: {
+                   name: :no_active_coverage_request_body,
+                   title: 'Request body to use for the "No Active Coverage" test',
+                   description: %(
+                     Provide a single JSON request body to submit for the hook invocation. The type of hook
+                     invoked will be inferred based on the `hook` element in the request. The body should be
+                     constructed so that it represents a resolvable patient without active coverage.
+                   )
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Requests'
+        simulation_verification
+
+        test from: :crd_v221_service_request_required_fields_validation,
+             config: {
+               outputs: {
+                 contexts: {
+                   name: :no_active_coverage_contexts
+                 }
+               }
+             }
+        test from: :crd_v221_service_request_context_validation,
+             config: {
+               inputs: {
+                 contexts: {
+                   name: :no_active_coverage_contexts
+                 },
+                 request_body: {
+                   name: :no_active_coverage_request_body
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Responses'
+
+        test from: :crd_v221_service_response_validation
+        test from: :crd_v221_coverage_info_system_action_validation,
+             config: {
+               outputs: {
+                 coverage_info: {
+                   name: :no_active_coverage_coverage_info
+                 }
+               }
+             }
+        test from: :crd_v221_coverage_info_reason,
+             title: 'Coverage Information responses have not-covered coverage for no-active-coverage reason',
+             description: <<~DESCRIPTION,
+               This test verifies that the Coverage Information responses received contain Coverage Information
+               extensions with `not-covered` coverage and a `no-active-coverage` reason.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 coverage_info: {
+                   name: :no_active_coverage_coverage_info
+                 }
+               },
+               options: {
+                 expected_coverage_code: 'not-covered',
+                 expected_reason_code: 'no-active-coverage'
+               }
+             },
+             verifies_requirements: [
+               'hl7.fhir.us.davinci-crd_2.2.1@resp-45'
+             ]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/no_member_found_group.rb

@@ -0,0 +1,117 @@
+require_relative '../interaction/server_invoke_hook_single_request_test'
+require_relative 'coverage_info_reason_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class NoMemberFoundGroup < Inferno::TestGroup
+      title 'No Member Found'
+      id :crd_v221_server_no_member_found_group
+      description %(
+        This group of tests allows the system to demonstrate its ability to respond to a CRD Hook invocation
+        with a `not-covered` coverage determination when it is unable to resolve the patient for a
+        non-technical reason.
+
+        For these tests, provide a hook request body that represents a patient/member the CRD Server cannot
+        resolve for a non-technical reason.
+
+        The tests then verify that a Coverage Information systemAction is received with `not-covered` coverage
+        for `no-member-found` reasons.
+      )
+
+      config options: { hook_name: NO_MEMBER_FOUND_TAG }
+      run_as_group
+
+      group do
+        title 'Interaction'
+
+        test from: :crd_v221_server_invoke_hook_single_request_test,
+             title: 'Inferno invokes the selected hook to elicit unresolved member response',
+             description: <<~DESCRIPTION,
+               This test initiates a POST request to a specified CDS Service using the JSON body provided
+               by the user. The request body should represent an unrecognized member.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 service_ids: {
+                   name: :no_member_found_service_ids,
+                   title: 'Service id to use for the "No Member Found" test',
+                   description: %(
+                     If blank, Inferno will attempt to infer the service id to use by finding a service entry
+                     in the Discovery response for the hook indicated in the provided request body. If it
+                     cannot be inferred, the tests will be skipped.
+                   )
+                 },
+                 service_request_bodies: {
+                   name: :no_member_found_request_body,
+                   title: 'Request body to use for the "No Member Found" test',
+                   description: %(
+                     Provide a single JSON request body to submit for the hook invocation. The type of hook
+                     invoked will be inferred based on the `hook` element in the request. The body should be
+                     constructed so that the CRD Server is unable to resolve the patient/member.
+                   )
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Requests'
+        simulation_verification
+
+        test from: :crd_v221_service_request_required_fields_validation,
+             config: {
+               outputs: {
+                 contexts: {
+                   name: :no_member_found_contexts
+                 }
+               }
+             }
+        test from: :crd_v221_service_request_context_validation,
+             config: {
+               inputs: {
+                 contexts: {
+                   name: :no_member_found_contexts
+                 },
+                 request_body: {
+                   name: :no_member_found_request_body
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Responses'
+
+        test from: :crd_v221_service_response_validation
+        test from: :crd_v221_coverage_info_system_action_validation,
+             config: {
+               outputs: {
+                 coverage_info: {
+                   name: :no_member_found_coverage_info
+                 }
+               }
+             }
+        test from: :crd_v221_coverage_info_reason,
+             title: 'Coverage Information responses have not-covered coverage for no-member-found reason',
+             description: <<~DESCRIPTION,
+               This test verifies that the Coverage Information responses received contain Coverage Information
+               extensions with `not-covered` coverage and a `no-member-found` reason.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 coverage_info: {
+                   name: :no_member_found_coverage_info
+                 }
+               },
+               options: {
+                 expected_coverage_code: 'not-covered',
+                 expected_reason_code: 'no-member-found'
+               }
+             },
+             verifies_requirements: [
+               'hl7.fhir.us.davinci-crd_2.2.1@resp-44'
+             ]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/technical_issues_group.rb

@@ -0,0 +1,121 @@
+require_relative 'technical_issues_invoke_test'
+require_relative 'coverage_info_reason_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class TechnicalIssuesGroup < Inferno::TestGroup
+      title 'Technical Issues'
+      id :crd_v221_server_technical_issues_group
+      description %(
+        This group of tests allows the system to demonstrate its ability to
+        respond to a CRD Hook invocation with an `indeterminate` coverage
+        determination due to technical issues.
+
+        For these tests, the hook call will include an invalid access token,
+        which due to the nature of Inferno's FHIR server simulation will result
+        in 500 response to FHIR requests, simulating a temporary server outage.
+        The tests then verify that a Coverage Information systemAction is
+        received with `indeterminate` coverage for `technical` reasons.
+      )
+
+      config options: { hook_name: TECHNICAL_ISSUES_TAG }
+      run_as_group
+
+      group do
+        title 'Interaction'
+
+        test from: :crd_v221_server_technical_issues_invoke_hook_test,
+             description: <<~DESCRIPTION,
+               This test initiates a POST request to a specified CDS Service
+               using the JSON body list provided by the user. This request is
+               generated so that requests for FHIR resources from the CDS service
+               result in 500 errors, simulating a temporary server error.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 service_ids: {
+                   name: :technical_issues_service_ids,
+                   title: 'Service id to use for the "Technical Issues" test',
+                   description: %(
+                     If blank, Inferno will attempt to infer the service id to use
+                     by finding a service entry in the Discovery response for the
+                     hook indicated in the provided request body. If it cannot be
+                     inferred, the tests will be skipped.
+                   )
+                 },
+                 service_request_bodies: {
+                   name: :technical_issues_request_body,
+                   title: 'Request body to use for the "Technical Issues" test',
+                   description: %(
+                     Provide a single JSON request body to submit for the hook
+                     invocation. The type of hook invoked will be inferred based
+                     on the `hook` element in the request.
+                   )
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Requests'
+        simulation_verification
+
+        test from: :crd_v221_service_request_required_fields_validation,
+             config: {
+               outputs: {
+                 contexts: {
+                   name: :technical_issues_contexts
+                 }
+               }
+             }
+        test from: :crd_v221_service_request_context_validation,
+             config: {
+               inputs: {
+                 contexts: {
+                   name: :technical_issues_contexts
+                 },
+                 request_body: {
+                   name: :technical_issues_request_body
+                 }
+               }
+             }
+      end
+
+      group do
+        title 'Responses'
+
+        test from: :crd_v221_service_response_validation
+        test from: :crd_v221_coverage_info_system_action_validation,
+             config: {
+               outputs: {
+                 coverage_info: {
+                   name: :technical_issues_coverage_info
+                 }
+               }
+             }
+        test from: :crd_v221_coverage_info_reason,
+             title: 'Coverage Information responses have indeterminate coverage for technical reasons',
+             description: <<~DESCRIPTION,
+               This test verifies that the Coverage Information responses received contain Coverage Information
+               extensions with `indeterminate` coverage and a `technical` reason, and additional details about the
+               failure are included in the `text` field of the reason extension.
+             DESCRIPTION
+             config: {
+               inputs: {
+                 coverage_info: {
+                   name: :technical_issues_coverage_info
+                 }
+               },
+               options: {
+                 expected_coverage_code: 'indeterminate',
+                 expected_reason_code: 'technical',
+                 require_reason_text: true
+               }
+             },
+             verifies_requirements: [
+               'hl7.fhir.us.davinci-crd_2.2.1@resp-43'
+             ]
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/specific_coverage_responses/technical_issues_invoke_test.rb

@@ -0,0 +1,22 @@
+require_relative '../server_urls'
+require_relative '../../jobs/invoke_hook_with_bad_auth'
+require_relative '../../server_abstract_invoke_hook_test'
+
+module DaVinciCRDTestKit
+  module V221
+    class TechnicalIssuesInvokeHookTest < ServerAbstractInvokeHookTest
+      include ServerURLs
+
+      title 'Inferno invokes the selected hook with invalid authorization'
+      id :crd_v221_server_technical_issues_invoke_hook_test
+
+      def perform_invoke_hook_job(*)
+        Inferno::Jobs.perform(DaVinciCRDTestKit::Jobs::InvokeHookWithBadAuth, *)
+      end
+
+      def check_request_length(payloads)
+        skip_if payloads.length != 1, 'The *Technical Issues* test supports only one request body.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/v2.2.1/verify_request/service_request_context_validation_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../server_hook_request_validation'
+require_relative '../../server_test_helper'
+require_relative '../../server_hook_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ServiceRequestContextValidationTest < Inferno::Test
+      include DaVinciCRDTestKit::ServerHookRequestValidation
+      include DaVinciCRDTestKit::ServerTestHelper
+      include DaVinciCRDTestKit::ServerHookHelper
+
+      title 'Service request contexts are valid'
+      id :crd_v221_service_request_context_validation
+      description %(
+        This test verifies that all service requests `context` field is valid and contains all the
+        required fields.
+      )
+      input :contexts, :invoked_hook
+      simulation_verification
+
+      run do
+        parsed_contexts = parse_json(contexts)
+        parsed_contexts.each do |context|
+          hook_request_context_check(context, invoked_hook, ig_version: 'v221')
+        end
+
+        no_error_validation('Some contexts are not valid.')
+      end
+    end
+  end
+end