davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/client_tests/decode_auth_token_test.rb

@@ -1,60 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class DecodeAuthTokenTest < Inferno::Test
-    include ClientHookRequestValidation
-    id :crd_decode_auth_token
-    title 'Bearer token can be decoded'
-    description %(
-        Verify that the Bearer token is a properly constructed JWT. As per the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#trusting-cds-clients),
-        each time a CDS Client transmits a request to a CDS Service which requires authentication, the request MUST
-        include an Authorization header presenting the JWT as a "Bearer" token.
-      )
-
-    output :auth_tokens, :auth_token_payloads_json, :auth_token_headers_json
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    run do
-      load_tagged_requests(hook_name)
-      skip_if requests.empty?, "No #{hook_name} requests were made in a previous test as expected."
-      auth_tokens = []
-      auth_token_payloads_json = []
-      auth_token_headers_json = []
-
-      requests.each_with_index do |request, index|
-        @request_number = index + 1
-
-        authorization_header = request.request_header('Authorization')&.value
-
-        unless authorization_header.start_with?('Bearer ')
-          add_message('error', "#{request_number}Authorization token must be a JWT presented as a `Bearer` token")
-        end
-
-        auth_token = authorization_header.delete_prefix('Bearer ')
-        auth_tokens << auth_token
-
-        begin
-          payload, header =
-            JWT.decode(
-              auth_token,
-              nil,
-              false
-            )
-
-          auth_token_payloads_json << payload.to_json
-          auth_token_headers_json << header.to_json
-        rescue StandardError => e
-          add_message('error', "#{request_number}Token is not a properly constructed JWT: #{e.message}")
-        end
-      end
-      output auth_tokens: auth_tokens.to_json,
-             auth_token_payloads_json: auth_token_payloads_json.to_json,
-             auth_token_headers_json: auth_token_headers_json.to_json
-
-      no_error_validation('Decoding Authorization header Bearer tokens failed.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/encounter_discharge_receive_request_test.rb

@@ -1,90 +0,0 @@
-require_relative '../urls'
-
-module DaVinciCRDTestKit
-  class EncounterDischargeReceiveRequestTest < Inferno::Test
-    include URLs
-
-    id :crd_encounter_discharge_request
-    title 'Request received for encounter-discharge hook'
-    description %(
-        This test waits for multiple incoming [encounter-discharge](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#encounter-discharge)
-        hook requests and responds to the client with the response types selected as an input.
-      )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@197', 'hl7.fhir.us.davinci-crd_2.0.1@243',
-                          'hl7.fhir.us.davinci-crd_2.0.1@244', 'hl7.fhir.us.davinci-crd_2.0.1@245'
-
-    config options: { accepts_multiple_requests: true }
-
-    input :cds_jwt_iss,
-          title: 'CRD JWT Issuer',
-          description: %(
-            Value of the `iss` claim that must be sent on the Bearer token in the `Authorization`
-            header of all requests. Run or re-run the **Client Registration** group to set or
-            change this value.
-          ),
-          locked: true
-    input :encounter_discharge_selected_response_types,
-          title: 'Response types to return from encounter-discharge hook requests',
-          description: %(
-            Select the cards/action response types that the Inferno hook request endpoints will return. The default
-            response type that will be returned for this hook is the `Instructions` card type.
-          ),
-          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'
-              }
-            ]
-          }
-    input :encounter_discharge_custom_response,
-          title: 'Custom response for encounter-discharge hook requests',
-          description: %(
-            A JSON string may be provided here to replace the normal response
-            from the hook request endpoint
-          ),
-          type: 'textarea',
-          optional: true
-
-    run do
-      wait(
-        identifier: "encounter-discharge #{cds_jwt_iss}",
-        message: %(
-          **Encounter Discharge CDS Service Test**:
-
-          Invoke the encounter-discharge hook and send requests to:
-
-          `#{encounter_discharge_url}`
-
-          Inferno will process the requests and return CDS cards if successful.
-
-          [Click here](#{resume_pass_url}?token=encounter-discharge%20#{cds_jwt_iss}) when you have finished submitting
-          requests.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/encounter_start_receive_request_test.rb

@@ -1,90 +0,0 @@
-require_relative '../urls'
-
-module DaVinciCRDTestKit
-  class EncounterStartReceiveRequestTest < Inferno::Test
-    include URLs
-
-    id :crd_encounter_start_request
-    title 'Request received for encounter-start hook'
-    description %(
-      This test waits for multiple incoming [encounter-start](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#encounter-start)
-      hook requests and responds to the client with the response types selected as an input.
-      )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@186', 'hl7.fhir.us.davinci-crd_2.0.1@243',
-                          'hl7.fhir.us.davinci-crd_2.0.1@244', 'hl7.fhir.us.davinci-crd_2.0.1@245'
-
-    config options: { accepts_multiple_requests: true }
-
-    input :cds_jwt_iss,
-          title: 'CRD JWT Issuer',
-          description: %(
-            Value of the `iss` claim that must be sent on the Bearer token in the `Authorization`
-            header of all requests. Run or re-run the **Client Registration** group to set or
-            change this value.
-          ),
-          locked: true
-    input :encounter_start_selected_response_types,
-          title: 'Response types to return from encounter-start hook requests',
-          description: %(
-            Select the cards/action response types that the Inferno hook request endpoints will return. The default
-            response type that will be returned for this hook is the `Instructions` card type.
-          ),
-          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'
-              }
-            ]
-          }
-    input :encounter_start_custom_response,
-          title: 'Custom response for encounter-start hook requests',
-          description: %(
-            A JSON string may be provided here to replace the normal response
-            from the hook request endpoint
-          ),
-          type: 'textarea',
-          optional: true
-
-    run do
-      wait(
-        identifier: "encounter-start #{cds_jwt_iss}",
-        message: %(
-          **Encounter Start CDS Service Test**:
-
-          Invoke the encounter-start hook and send requests to:
-
-          `#{encounter_start_url}`
-
-          Inferno will process the requests and return CDS cards if successful.
-
-          [Click here](#{resume_pass_url}?token=enounter-start%20#{cds_jwt_iss}) when you have finished submitting
-          requests.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/hook_request_optional_fields_test.rb

@@ -1,57 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class HookRequestOptionalFieldsTest < Inferno::Test
-    include ClientHookRequestValidation
-    include URLs
-
-    id :crd_hook_request_optional_fields
-    title 'Hook request contains optional fields'
-    description %(
-      Under the [CDS hooks HTTP Request section](https://cds-hooks.hl7.org/2.0/#http-request_1), the specification
-      requires that a CDS service request SHALL include a JSON POST body which MAY contain the following optional input
-      fields:
-        * `fhirServer` - *URL*
-        * `fhirAuthorization` - *object*
-        * `prefetch` - *object*
-
-      This test checks for the presence of these fields and if they are of the correct type. This test is optional and
-      will not fail if the hook request does not contain an optional field, it only produces an informational message.
-      If the client provides its FHIR server URL in the `fhirServer` field, and it's authorization token in the
-      `fhirAuthorization` field object, they will be produced as an output from this test to be used in
-      subsequent tests.
-    )
-    optional
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    output :client_fhir_server
-    output :client_access_token,
-           optional: true
-
-    run do
-      load_tagged_requests(hook_name)
-      skip_if requests.empty?, "No #{hook_name} requests were made in a previous test as expected."
-      client_fhir_server = nil
-      requests.each_with_index do |request, index|
-        @request_number = index + 1
-        request_body = json_parse(request.request_body)
-        if request_body.blank?
-          add_message('error', "#{request_number}Hook request body cannot be empty.")
-          next
-        end
-
-        fhir_server_info = hook_request_optional_fields_check(request_body)
-        client_fhir_server ||= fhir_server_info
-      end
-
-      unless client_fhir_server.nil?
-        output client_fhir_server: client_fhir_server[:fhir_server_uri],
-               client_access_token: client_fhir_server[:fhir_access_token]
-      end
-      no_error_validation('Some service requests contain invalid optional fields.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/hook_request_required_fields_test.rb

@@ -1,49 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class HookRequestRequiredFieldsTest < Inferno::Test
-    include ClientHookRequestValidation
-    include URLs
-
-    id :crd_hook_request_required_fields
-    title 'Hook request contains required fields'
-    description %(
-      Under the [CDS hooks HTTP Request section](https://cds-hooks.hl7.org/2.0/#http-request_1), the specification
-      requires that a CDS service request SHALL include a JSON POST body with the following input fields:
-        * `hook` - *string*
-        * `hookInstance` - *string*
-        * `context` - *object*
-
-        Additionally, if the optional `fhirAuthorization` field is present, then the `fhirServer` field is required.
-
-        This test also checks that the `hook` field contains the correct CDS service name that the CDS client is sending
-        a request for
-    )
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    output :contexts, :prefetches
-
-    run do
-      load_tagged_requests(hook_name)
-      skip_if requests.empty?, "No #{hook_name} requests were made in a previous test as expected."
-      contexts = []
-      prefetches = []
-      requests.each_with_index do |request, index|
-        @request_number = index + 1
-        request_body = json_parse(request.request_body)
-        next if request_body.blank?
-
-        contexts << request_body['context'] if request_body['context'].is_a?(Hash)
-        prefetches << request_body['prefetch'] if request_body['prefetch'].is_a?(Hash)
-        hook_request_required_fields_check(request_body, hook_name)
-      end
-
-      output contexts: contexts.to_json,
-             prefetches: prefetches.to_json
-      no_error_validation('Some service requests made are not valid.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/hook_request_valid_context_test.rb

@@ -1,68 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class HookRequestValidContextTest < Inferno::Test
-    include URLs
-    include ClientHookRequestValidation
-
-    id :crd_hook_request_valid_context
-    title 'Hook contains valid context'
-    description %(
-      As stated in the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#http-request), a CDS service request's
-      `context` field contains hook-specific contextual data that the CDS service will need. The context is specified
-      in the hook definition to guide developers on the information available at the point in the workflow when the hook
-      is triggered.
-
-      The `context` requirements for each [hook specified in the CRD IG](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html)
-      can be found below:
-      * [appointment-book](https://cds-hooks.hl7.org/hooks/appointment-book/2023SepSTU1Ballot/appointment-book/)
-      * [encounter-start](https://cds-hooks.hl7.org/hooks/encounter-start/2023SepSTU1Ballot/encounter-start/)
-      * [encounter-discharge](https://cds-hooks.hl7.org/hooks/encounter-discharge/2023SepSTU1Ballot/encounter-discharge/)
-      * [order-select](https://cds-hooks.hl7.org/hooks/order-select/2023SepSTU1Ballot/order-select/)
-      * [order-dispatch](https://cds-hooks.hl7.org/hooks/order-dispatch/2023SepSTU1Ballot/order-dispatch/)
-      * [order-sign](https://cds-hooks.org/hooks/order-sign/)
-
-      This test performs the following:
-        * Verifies that the incoming hook request's `context` field contains the fields required by each hook and
-        that they are in the correct format
-        * Checks the optional fields and ensures they are in the correct format
-        * Validates any resources contained in a `context` field that contains a Bundle or FHIR resource
-        * Makes FHIR requests for any `context` fields that contain an id or reference and validates each resource
-        response against its corresponding CRD resource profile
-        * Check some specific `context` requirements for hooks that have special requirements for certain fields
-
-      The client must provide its FHIR server URL and access token in the hook request in order to run
-      this test.
-    )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@254'
-
-    input :contexts, :client_fhir_server
-    input :client_access_token,
-          optional: true
-
-    fhir_client do
-      url :client_fhir_server
-      bearer_token :client_access_token
-    end
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    run do
-      hook_contexts = json_parse(contexts)
-      if hook_contexts
-        skip_if(hook_contexts.none?(&:present?), "No #{hook_name} requests contained the `context` field.")
-        hook_contexts.each_with_index do |context, index|
-          @request_number = index + 1
-          if context.blank?
-            add_message('error', "#{request_number}Missing required context field.")
-            next
-          end
-          hook_request_context_check(context, hook_name)
-        end
-      end
-      no_error_validation('Context is not valid.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/hook_request_valid_prefetch_test.rb

@@ -1,69 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class HookRequestValidPrefetchTest < Inferno::Test
-    include ClientHookRequestValidation
-    include URLs
-
-    id :crd_hook_request_valid_prefetch
-    title 'Hook contains valid prefetch response'
-    description %(
-      As stated in the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#http-request), a CDS service request's
-      `prefetch` field is an optional field that contains key/value pairs of FHIR queries that the service is requesting
-      the CDS Client to perform and provide on each service call. The key is a string that describes the type of data
-      being requested and the value is a string representing the FHIR query. See [Prefetch Template](https://cds-hooks.hl7.org/2.0#prefetch-template)
-      for more information about how the `prefetch` formatting works.
-
-      This test verifies that the incoming hook request's `prefetch` field is in a valid JSON format and validates each
-      contained resource against its corresponding CRD resource profile. This test is optional and will be skipped if no
-      `prefetch` field is contained in the hook request.
-    )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@43'
-    optional
-
-    input :contexts, :prefetches
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    def cds_services_json
-      JSON.parse(File.read(File.join(
-                             __dir__, '..', 'routes', 'cds-services.json'
-                           )))['services']
-    end
-
-    def advertised_prefetch_fields
-      advertised_hook_service = cds_services_json.find { |service| service['hook'] == hook_name }
-      advertised_hook_service['prefetch']
-    end
-
-    run do
-      hook_contexts = json_parse(contexts)
-      hook_prefetches = json_parse(prefetches)
-
-      if hook_contexts && hook_prefetches
-        skip_if(hook_prefetches.none? do |prefetch|
-          prefetch_index = hook_prefetches.find_index(prefetch)
-          prefetch.present? && hook_contexts[prefetch_index].present?
-        end, "No #{hook_name} requests contained both the `context` and `prefetch` field.")
-
-        hook_prefetches.each_with_index do |prefetch, index|
-          @request_number = index + 1
-          context = hook_contexts[index]
-
-          info "#{request_number}Received hook request does not contain the `prefetch` field." if prefetch.blank?
-          if context.blank?
-            info %(#{request_number}Received hook request does not contain the `context` field
-            which is needed to validate the `prefetch` field)
-          end
-
-          next if prefetch.blank? || context.blank?
-
-          hook_request_prefetch_check(advertised_prefetch_fields, prefetch, context)
-        end
-      end
-      no_error_validation('Prefetch is not valid.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/order_dispatch_receive_request_test.rb

@@ -1,102 +0,0 @@
-require_relative '../urls'
-
-module DaVinciCRDTestKit
-  class OrderDispatchReceiveRequestTest < Inferno::Test
-    include URLs
-
-    id :crd_order_dispatch_request
-    title 'Request received for order-dispatch hook'
-    description %(
-        This test waits for multiple incoming [order-dispatch](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-dispatch)
-        hook requests and responds to the client with the response types selected as an input. This hook is a 'primary'
-        hook, meaning that CRD Servers SHALL, at minimum, return a [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/StructureDefinition-ext-coverage-information.html)
-        system action for these hooks, even if the response indicates that further information is needed or that the
-        level of detail provided is insufficient to determine coverage.
-      )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@205',
-                          'hl7.fhir.us.davinci-crd_2.0.1@207', 'hl7.fhir.us.davinci-crd_2.0.1@243',
-                          'hl7.fhir.us.davinci-crd_2.0.1@244', 'hl7.fhir.us.davinci-crd_2.0.1@245'
-
-    config options: { accepts_multiple_requests: true }
-
-    input :cds_jwt_iss,
-          title: 'CRD JWT Issuer',
-          description: %(
-            Value of the `iss` claim that must be sent on the Bearer token in the `Authorization`
-            header of all requests. Run or re-run the **Client Registration** group to set or
-            change this value.
-          ),
-          locked: true
-    input :order_dispatch_selected_response_types,
-          title: 'Response types to return from order-dispatch hook requests',
-          description: %(
-            Select the cards/action response types that the Inferno hook request endpoints will return. The default
-            response type that will be returned for this hook is the `Coverage Information` card type.
-          ),
-          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'
-              }
-            ]
-          }
-    input :order_dispatch_custom_response,
-          title: 'Custom response for order-dispatch hook requests',
-          description: %(
-            A JSON string may be provided here to replace the normal response
-            from the hook request endpoint
-          ),
-          type: 'textarea',
-          optional: true
-
-    run do
-      wait(
-        identifier: "order-dispatch #{cds_jwt_iss}",
-        message: %(
-          **Order Dispatch CDS Service Test**:
-
-          Invoke the order-dispatch hook and send requests to:
-
-          `#{order_dispatch_url}`
-
-          Inferno will process the requests and return CDS cards if successful.
-
-          [Click here](#{resume_pass_url}?token=order-dispatch%20#{cds_jwt_iss}) when you have finished submitting
-          requests.
-        )
-      )
-    end
-  end
-end