davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/client/v2.2.1/invocation/order_select_receive_request_test.rb

@@ -0,0 +1,165 @@
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class OrderSelectReceiveRequestTest < Inferno::Test
+      include ClientURLs
+
+      id :crd_v221_order_select_request
+      title 'Client invokes the order-select hook'
+      description %(
+        During this test, Inferno will wait while the client makes one or more [order-select](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/hooks.html#order-select)
+        hook requests against Inferno's simulated CRD servers. Inferno will respond
+        based on the response configuration provided when running the test.
+        For more details on how Inferno's simulated CRD servers behave during
+        hook invocation see the [simulated CRD server](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Details#crd-server-simulation)
+        documentation.
+
+        Inferno will pause and wait for inbound requests until told explicitly to continue
+        by the tester by clicking on the link in the "User Action Required" dialog (NOTE: after
+        5 minutes the test will become inactive and unresponsive to anything except cancelation).
+      )
+
+      config options: { accepts_multiple_requests: true }
+
+      input :cds_jwt_iss,
+            title: 'CRD JWT Issuer',
+            description: %(
+              Value of the `iss` claim that must be present in the JWT used to authorize the client's hook
+              request sent as the Bearer token in the `Authorization` header.
+              Run or re-run the "Registration" group to set or change this value.
+            ),
+            locked: true
+      input :order_select_response_approach,
+            title: 'Response generation approach for order-select',
+            description: %(
+              Determines how Inferno will generate response for order-select
+              hook invocations.
+            ),
+            type: 'radio',
+            default: 'mocked',
+            options: {
+              list_options: [
+                {
+                  label: 'Create simple mocks based on selected response types',
+                  value: 'mocked'
+                },
+                {
+                  label: 'Generate responses based on a tester-provided template',
+                  value: 'custom'
+                }
+              ]
+            }
+      input :order_select_selected_response_types,
+            title: 'Response types to return from order-select hook requests',
+            description: %(
+              Select the CRD response types that the simulated Inferno CRD server will [mock](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+              when responding to hook invocations. If no types are selected, Inferno will mock and return
+              an [Instructions](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#instructions-response-type)
+              response for this secondary hook.
+            ),
+            type: 'checkbox',
+            default: ['coverage_information', 'external_reference', 'instructions'],
+            optional: true,
+            options: {
+              list_options: [
+                {
+                  label: 'External Reference',
+                  value: 'external_reference'
+                },
+                {
+                  label: 'Instructions',
+                  value: 'instructions'
+                },
+                {
+                  label: 'Coverage Information',
+                  value: 'coverage_information'
+                },
+                {
+                  label: 'Request Form Completion',
+                  value: 'request_form_completion'
+                },
+                {
+                  label: 'Create/Update Coverage Information',
+                  value: 'create_update_coverage_info'
+                },
+                {
+                  label: 'Launch SMART Application',
+                  value: 'launch_smart_app'
+                },
+                {
+                  label: 'Propose Alternate Request',
+                  value: 'propose_alternate_request'
+                },
+                {
+                  label: 'Additional Orders as Companions/Prerequisites',
+                  value: 'companions_prerequisites'
+                }
+              ]
+            },
+            enable_when: { input_name: 'order_select_response_approach', value: 'mocked' }
+      input :order_select_custom_response_template,
+            title: 'Custom response template for order-select hook requests',
+            description: %(
+              Provide a [custom response template](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#tester-directed-custom-responses)
+              in JSON form for Inferno to use when responding to hook invocations.
+            ),
+            type: 'textarea',
+            optional: true,
+            enable_when: { input_name: 'order_select_response_approach', value: 'custom' }
+      output :continuation_url
+
+      def configured_response_details
+        if order_select_response_approach == 'custom'
+          # rubocop:disable Layout/LineLength
+          'When responding, Inferno will evaluate the provided [custom response template](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#tester-directed-custom-responses) ' \
+            'from the **Custom response template for order-select hook requests** input ' \
+            'against the incoming request to create a response.'
+          # rubocop:enable Layout/LineLength
+
+        else
+          # rubocop:disable Layout/LineLength
+          'When responding, Inferno will [mock](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses) ' \
+            'the following response types using the incoming request: ' \
+            "\n            - #{selected_response_types_string}"
+          # rubocop:enable Layout/LineLength
+        end
+      end
+
+      def selected_response_types_string
+        if order_select_selected_response_types.present?
+          order_select_selected_response_types.join("\n            - ")
+        else
+          'Instructions' # secondary hook default
+        end
+      end
+
+      run do
+        identifier = cds_jwt_iss
+        continuation_url = "#{resume_pass_url}?token=#{identifier}"
+        output(continuation_url:)
+
+        wait(
+          identifier:,
+          message: %(
+            **Invoke the `order-select` hook**:
+
+            Invoke the order-select hook by sending requests to
+            one or both of the two Inferno simulated CRD servers:
+
+            - Complete Prefetch: `#{order_select_url}`
+            - Subset Prefetch: `#{order_select_prefetch_subset_url}`
+
+            For Inferno to recognize these requests and associate them with this session,
+            the authentication JWT sent as a Bearer token in the Authorization header
+            must have `#{cds_jwt_iss}` as the `iss` claim in the JWT payload.
+
+            #{configured_response_details}
+
+            [Click here](#{continuation_url}) when you have finished submitting requests.
+          )
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/invocation/order_sign_receive_request_test.rb

@@ -0,0 +1,165 @@
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class OrderSignReceiveRequestTest < Inferno::Test
+      include ClientURLs
+
+      id :crd_v221_order_sign_request
+      title 'Client invokes the order-sign hook'
+      description %(
+        During this test, Inferno will wait while the client makes one or more [order-sign](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/hooks.html#order-sign)
+        hook requests against Inferno's simulated CRD servers. Inferno will respond
+        based on the response configuration provided when running the test.
+        For more details on how Inferno's simulated CRD servers behave during
+        hook invocation see the [simulated CRD server](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Client-Details#crd-server-simulation)
+        documentation.
+
+        Inferno will pause and wait for inbound requests until told explicitly to continue
+        by the tester by clicking on the link in the "User Action Required" dialog (NOTE: after
+        5 minutes the test will become inactive and unresponsive to anything except cancelation).
+      )
+
+      config options: { accepts_multiple_requests: true }
+
+      input :cds_jwt_iss,
+            title: 'CRD JWT Issuer',
+            description: %(
+              Value of the `iss` claim that must be present in the JWT used to authorize the client's hook
+              request sent as the Bearer token in the `Authorization` header.
+              Run or re-run the "Registration" group to set or change this value.
+            ),
+            locked: true
+      input :order_sign_response_approach,
+            title: 'Response generation approach for order-sign',
+            description: %(
+              Determines how Inferno will generate response for order-sign
+              hook invocations.
+            ),
+            type: 'radio',
+            default: 'mocked',
+            options: {
+              list_options: [
+                {
+                  label: 'Create simple mocks based on selected response types',
+                  value: 'mocked'
+                },
+                {
+                  label: 'Generate responses based on a tester-provided template',
+                  value: 'custom'
+                }
+              ]
+            }
+      input :order_sign_selected_response_types,
+            title: 'Response types to return from order-sign hook requests',
+            description: %(
+              Select the CRD response types that the simulated Inferno CRD server will [mock](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+              when responding to hook invocations. If no types are selected, Inferno will mock and return
+              a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/cards.html#coverage-information-response-type)
+              response for this primary hook.
+            ),
+            type: 'checkbox',
+            default: ['coverage_information', 'external_reference', 'instructions'],
+            optional: true,
+            options: {
+              list_options: [
+                {
+                  label: 'External Reference',
+                  value: 'external_reference'
+                },
+                {
+                  label: 'Instructions',
+                  value: 'instructions'
+                },
+                {
+                  label: 'Coverage Information',
+                  value: 'coverage_information'
+                },
+                {
+                  label: 'Request Form Completion',
+                  value: 'request_form_completion'
+                },
+                {
+                  label: 'Create/Update Coverage Information',
+                  value: 'create_update_coverage_info'
+                },
+                {
+                  label: 'Launch SMART Application',
+                  value: 'launch_smart_app'
+                },
+                {
+                  label: 'Propose Alternate Request',
+                  value: 'propose_alternate_request'
+                },
+                {
+                  label: 'Additional Orders as Companions/Prerequisites',
+                  value: 'companions_prerequisites'
+                }
+              ]
+            },
+            enable_when: { input_name: 'order_sign_response_approach', value: 'mocked' }
+      input :order_sign_custom_response_template,
+            title: 'Custom response template for order-sign hook requests',
+            description: %(
+              Provide a [custom response template](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#tester-directed-custom-responses)
+              in JSON form for Inferno to use when responding to hook invocations.
+            ),
+            type: 'textarea',
+            optional: true,
+            enable_when: { input_name: 'order_sign_response_approach', value: 'custom' }
+      output :continuation_url
+
+      def configured_response_details
+        if order_sign_response_approach == 'custom'
+          # rubocop:disable Layout/LineLength
+          'When responding, Inferno will evaluate the provided [custom response template](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#tester-directed-custom-responses) ' \
+            'from the **Custom response template for order-sign hook requests** input ' \
+            'against the incoming request to create a response.'
+          # rubocop:enable Layout/LineLength
+
+        else
+          # rubocop:disable Layout/LineLength
+          'When responding, Inferno will [mock](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses) ' \
+            'the following response types using the incoming request: ' \
+            "\n            - #{selected_response_types_string}"
+          # rubocop:enable Layout/LineLength
+        end
+      end
+
+      def selected_response_types_string
+        if order_sign_selected_response_types.present?
+          order_sign_selected_response_types.join("\n            - ")
+        else
+          'Coverage Information' # primary hook default
+        end
+      end
+
+      run do
+        identifier = cds_jwt_iss
+        continuation_url = "#{resume_pass_url}?token=#{identifier}"
+        output(continuation_url:)
+
+        wait(
+          identifier:,
+          message: %(
+            **Invoke the `order-sign` hook**:
+
+            Invoke the order-sign hook by sending requests to
+            one or both of the two Inferno simulated CRD servers:
+
+            - Complete Prefetch: `#{order_sign_url}`
+            - Subset Prefetch: `#{order_sign_prefetch_subset_url}`
+
+            For Inferno to recognize these requests and associate them with this session,
+            the authentication JWT sent as a Bearer token in the Authorization header
+            must have `#{cds_jwt_iss}` as the `iss` claim in the JWT payload.
+
+            #{configured_response_details}
+
+            [Click here](#{continuation_url}) when you have finished submitting requests.
+          )
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/long_running/client_long_running_receive_request_test.rb

@@ -0,0 +1,64 @@
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientLongRunningReceiveRequestTest < Inferno::Test
+      include ClientURLs
+
+      id :crd_v221_client_long_running_receive_request
+      title 'Client invokes any hook'
+      description %(
+        During this test, Inferno will wait while the client makes a single hook requests of any type.
+        Inferno will return a [mocked response](https://github.com/inferno-framework/davinci-crd-test-kit/wiki/Controlling-Simulated-Responses#mocked-responses)
+        but only after pausing for a configured amount of time, which must be 5 seconds or longer. The details
+        of the request and its response do not matter for the purposes of this test and they will not be
+        evaluated, checked for conformance, or included in cross-hook evaluations. The test will automatically
+        continue after Inferno receives a hook request, the configured pause time has elapsed,
+        and a response has been returned.
+      )
+      config options: { accepts_multiple_requests: true }
+
+      input :cds_jwt_iss,
+            title: 'CRD JWT Issuer',
+            description: %(
+              Value of the `iss` claim that must be present in the JWT used to authorize the client's hook
+              request sent as the Bearer token in the `Authorization` header.
+              Run or re-run the "Registration" group to set or change this value.
+            ),
+            locked: true
+      input :long_running_pause_time,
+            title: 'Long-running Request Pause Time',
+            description: %(
+              Time in seconds to wait before returning a response to a hook invocation
+              made when testing a long-running request. Must be at least 5 seconds,
+              which is the minimum threshold for a long-running response as defined by CRD.
+            ),
+            default: '5'
+
+      run do
+        verify_long_running_pause_time_input
+
+        identifier = cds_jwt_iss
+        wait(
+          identifier:,
+          message: %(
+            **Long Running Hook Request Test**:
+
+            Invoke any supported hook. This test will
+            automatically continue once Inferno has received a request, paused
+            for #{long_running_pause_time.to_i} seconds, and returned a response.
+
+            Users must have the option to continue
+            their workflow before Inferno's response is returned. Testers will be asked to
+            attest that this was demonstrated in the next test.
+          )
+        )
+      end
+
+      def verify_long_running_pause_time_input
+        assert long_running_pause_time.to_i >= 5,
+               'The **Long-running Request Pause Time** input must be at least 5 seconds.'
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/long_running/client_skip_long_running_attestation_test.rb

@@ -0,0 +1,49 @@
+require_relative '../client_urls'
+require_relative '../../tagged_request_load_helper'
+
+module DaVinciCRDTestKit
+  module V221
+    class ClientSkipLongRunningAttestationTest < Inferno::Test
+      include ClientURLs
+      include DaVinciCRDTestKit::TaggedRequestLoadHelper
+
+      id :crd_v221_client_skip_long_running_attestation_test
+      title 'Client allows the user to continue their workflow during long-running requests (Attestation)'
+      description %(
+        During this test, the tester will confirm that the client system allowed
+        its user to continue with their workflow while the sytem was waiting for the previous
+        long-running hook request to return.
+      )
+
+      verifies_requirements 'hl7.fhir.us.davinci-crd_2.2.1@found-6'
+
+      output :attest_true_url
+      output :attest_false_url
+
+      run do
+        long_running_requests = load_hook_requests
+        skip_if long_running_requests.blank?, 'Long-running requests not demonstrated: ' \
+                                              'no hook requests sent during the previous wait.'
+
+        identifier = SecureRandom.hex(32)
+        attest_true_url = "#{resume_pass_url}?token=#{identifier}"
+        attest_false_url = "#{resume_fail_url}?token=#{identifier}"
+        output(attest_true_url:)
+        output(attest_false_url:)
+        wait(
+          identifier:,
+          message: <<~MESSAGE
+            **Long Running Request Attestation**:
+
+            I attest that the user had the option to continue their workflow
+            while waiting for the long-running hook request to return a response:
+
+            [Click here](#{attest_true_url}) if the above statement is **true**.
+
+            [Click here](#{attest_false_url}) if the above statement is **false**.
+          MESSAGE
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client/v2.2.1/registration/client_registration_verification_test.rb

@@ -0,0 +1,161 @@
+require 'jwt'
+require_relative '../client_urls'
+
+module DaVinciCRDTestKit
+  module V221
+    class CRDClientRegistrationVerification < Inferno::Test
+      include ClientURLs
+
+      id :crd_v221_client_registration_verification
+      title 'CRD client registers with Inferno'
+      description %(
+        In order to register with and be able to make hook requests against Inferno's
+        simulated CRD servers, the tester must provide the `iss` (issuer) claim in
+        the payload of the JWT sent in the Authorization header of hook requests
+        made by the client against Inferno. This information is used to
+        associate inbound requests to Inferno's simulated CRD servers with this session.
+        Requests made without a JWT or with a different `iss` value will not appear in this
+        session or be analyzed.
+
+        Inferno also requires some additional information to verify conformant client behavior.
+        This information is not needed to execute the tests, but the tests will not completely
+        pass without it:
+        - A JSON Web Key Set (JWKS) containing the key used to sign the JWT sent in the Authorization
+          header for use in signature validation. It can be provided either as a URL where it is
+          publicly hosted (preferred) or the raw JWKS as JSON.
+        - A FHIR Organization id associated with each of Inferno's two simulated CRD servers,
+          one at `#{ClientURLs.discovery_url}` requesting the [complete standard prefetch data set](https://hl7.org/fhir/us/davinci-crd/2.2.1/en/foundation.html#standard-prefetch),
+          and the other at `#{ClientURLs.prefetch_subset_discovery_url}` requesting a subset of that data set.
+          These are used to verify that the prefetched coverage is linked to the correct payer for the invoked
+          service.
+
+        During this test, registration information provided will be checked for conformance
+        with these requirements.
+      )
+
+      verifies_requirements 'cds-hooks_3.0.0-ballot@199'
+
+      input :cds_jwt_iss,
+            title: 'CRD JWT Issuer',
+            description: %(
+              Value of the `iss` claim that will be sent in the JWT used to authorize the client's hook
+              request sent as the Bearer token in the `Authorization` header.
+              This value will be used to associate incoming requests with this test
+              session and any requests that use a different `iss` value will not be recognized.
+            ),
+            type: 'text'
+      input :cds_jwk_set,
+            title: 'CRD JSON Web Key Set (JWKS)',
+            type: 'textarea',
+            description: %(
+              The CRD client's JWK Set containing it's public key. May be either
+              a publicly accessible url containing the JWKS, or the raw JWKS.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+            ),
+            optional: true
+      input :complete_prefetch_service_organization_id,
+            title: 'Complete Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              complete prefetch CRD server. This Organization must be referenced as the
+              payer on Coverages in hook requests made to services described by the
+              `#{ClientURLs.discovery_url}` discovery endpoint.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+            ),
+            type: 'text',
+            optional: true
+      input :subset_prefetch_service_organization_id,
+            title: 'Subset Prefetch Service Organization id',
+            description: %(
+              The FHIR Organization id associated with Inferno's simulated
+              subset prefetch CRD server. This Organization must be referenced
+              payer on Coverages in hook requests made to services described by the
+              `#{ClientURLs.prefetch_subset_discovery_url}` discovery endpoint.
+              The client suite may be run without this input, but it is required
+              for the tests to pass.
+            ),
+            type: 'text',
+            optional: true
+
+      run do
+        if cds_jwk_set.present?
+          check_jwks
+        else
+          add_message('error', 'Provide a jwk set in the **CRD JSON Web Key Set (JWKS)** input.')
+        end
+
+        unless complete_prefetch_service_organization_id.present?
+          add_message('error', 'Provide an Organization id associated with the Complete Prefetch Service ' \
+                               "at endpoint #{discovery_url}")
+        end
+
+        unless subset_prefetch_service_organization_id.present?
+          add_message('error', 'Provide an Organization id associated with the Subset Prefetch Service ' \
+                               "at endpoint #{prefetch_subset_discovery_url}")
+        end
+
+        unless complete_prefetch_service_organization_id.present? && subset_prefetch_service_organization_id.present? &&
+               complete_prefetch_service_organization_id != subset_prefetch_service_organization_id
+          add_message('error', 'Each Inferno CRD service must be assigned a unique Organization id.')
+        end
+
+        assert_no_error_messages 'Invalid registration information provided. See Messages for details.'
+      end
+
+      def check_jwks
+        jwks_warnings = []
+        parsed_jwk_set = jwk_set(cds_jwk_set, jwks_warnings)
+        jwks_warnings.each { |warning| add_message('warning', warning) }
+
+        add_message('error', 'JWKS content does not include any valid keys.') unless parsed_jwk_set.length.positive?
+      end
+
+      def jwk_set(jku, warning_messages = []) # rubocop:disable Metrics/CyclomaticComplexity
+        jwk_set = JWT::JWK::Set.new
+
+        if jku.blank?
+          warning_messages << 'No key set input.'
+          return jwk_set
+        end
+
+        jwk_body = # try as raw jwk set
+          begin
+            JSON.parse(jku)
+          rescue JSON::ParserError
+            nil
+          end
+
+        if jwk_body.blank?
+          retrieved = Faraday.get(jku) # try as url pointing to a jwk set
+          jwk_body =
+            begin
+              JSON.parse(retrieved.body)
+            rescue JSON::ParserError
+              warning_messages << "Failed to fetch valid json from jwks uri #{jku}."
+              nil
+            end
+        else
+          warning_messages << 'Providing the JWK Set directly is strongly discouraged.'
+        end
+
+        return jwk_set if jwk_body.blank?
+
+        jwk_body['keys']&.each_with_index do |key_hash, index|
+          parsed_key =
+            begin
+              JWT::JWK.new(key_hash)
+            rescue JWT::JWKError => e
+              id = key_hash['kid'] | index
+              warning_messages << "Key #{id} invalid: #{e}"
+              nil
+            end
+          jwk_set << parsed_key unless parsed_key.blank?
+        end
+
+        jwk_set
+      end
+    end
+  end
+end