davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/crd_server_suite.rb

@@ -1,125 +0,0 @@
-require_relative 'jwt_helper'
-require_relative 'routes/jwk_set_endpoint_handler'
-require_relative 'server_discovery_group'
-require_relative 'server_demonstrate_hook_response_group'
-require_relative 'server_hooks_group'
-
-module DaVinciCRDTestKit
-  class CRDServerSuite < Inferno::TestSuite
-    id :crd_server
-    title 'Da Vinci CRD Server Test Suite'
-    description <<~DESCRIPTION
-      The Da Vinci CRD Server Test Suite tests the conformance of server systems
-      to [version 2.0.1 of the Da Vinci Coverage Requirements Discovery (CRD)
-      Implementation Guide](https://hl7.org/fhir/us/davinci-crd/STU2).
-
-      ## Overview
-      This suite contains three groups of tests:
-      1. The *Discovery* group validates a CRD server's discovery response.
-      2. The *Demonstrate A Hook Response* group validates that the server
-         can respond to a single hook invocation and return conformant cards.
-      3. The *Hooks* group makes one or more CDS Hooks calls for each hook
-         type that the tester provides request bodies for. It then validates that the
-         responses are conformant and cover the full range of cards as
-         required by the hook type.
-
-      ## Trusting CDS Clients
-      As specified in the [CDS Hooks Spec](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:
-      `Authorization:  Bearer {{JWT}}`
-
-      Inferno self-issues the JWT for each CDS Service call. The following
-      info is needed to register Inferno:
-
-        - **ISS**:  `#{Inferno::Application[:base_url]}/custom/crd_server`
-        - **JWK Set Url**:
-            `#{Inferno::Application[:base_url]}/custom/crd_server/jwks.json`
-
-      ## Running the Tests
-      Execution of these tests require a significant amount of tester input in
-      the form of requests that Inferno will make against the server under test.
-
-      If you would like to try out the tests using examples from the IG and the
-      [CDS Hooks spec](https://cds-hooks.hl7.org/2.0/) against [the public CRD
-      reference server endpoint](https://crd.davinci.hl7.org/), you can do so
-      by:
-      1. Selecting the *CRD Server RI* option from the
-         Preset dropdown in the upper left
-      2. Clicking the *Run All Tests* button in the upper right
-      3. Clicking the *Submit* button at the bottom of the input dialog
-
-      You can run these tests using your own server by updating the "CRD server
-      base URL" and, if needed, providing requests inputs you wish to use for
-      each hook your server supports.
-
-      Note that the provided inputs for these tests are not complete and systems
-      are not expected to pass the tests based on them.
-
-
-      ## Limitations
-      Inferno is unable to determine what requests will result in specific kinds
-      of responses from the server under test (e.g., what will result in
-      Instructions being returned vs. Coverage Information). As a result, the
-      tester must supply the request bodies which will cause the system under
-      test to return the desired response types.
-
-      The ability of a CRD Server to request additional FHIR resources is not
-      tested. Hook configuration is not tested.
-    DESCRIPTION
-
-    suite_summary <<~SUMMARY
-      The Da Vinci CRD Server Test Suite tests the conformance of server systems
-      to [version 2.0.1 of the Da Vinci Coverage Requirements Discovery (CRD)
-      Implementation Guide](https://hl7.org/fhir/us/davinci-crd/STU2).
-    SUMMARY
-
-    links [
-      {
-        label: 'Report Issue',
-        url: 'https://github.com/inferno-framework/davinci-crd-test-kit/issues'
-      },
-      {
-        label: 'Open Source',
-        url: 'https://github.com/inferno-framework/davinci-crd-test-kit'
-      },
-      {
-        label: 'Download',
-        url: 'https://github.com/inferno-framework/davinci-crd-test-kit/releases'
-      }
-    ]
-
-    requirement_sets(
-      {
-        identifier: 'hl7.fhir.us.davinci-crd_2.0.1',
-        title: 'Da Vinci Coverage Requirements Discovery (CRD) v2.0.1',
-        actor: 'Server'
-      }
-    )
-
-    input :base_url,
-          title: 'CRD server base URL'
-
-    fhir_resource_validator do
-      igs('hl7.fhir.us.davinci-crd#2.0.1')
-
-      exclude_message do |message|
-        message.message.match?(/\A\S+: \S+: URL value '.*' does not resolve/)
-      end
-    end
-
-    def inferno_base_url
-      suite_id = self.class.suite.id
-      @inferno_base_url ||= "#{Inferno::Application['base_url']}/custom/#{suite_id}"
-    end
-
-    route :get, '/jwks.json', Routes::JWKSetEndpointHandler
-
-    group from: :crd_server_discovery_group
-
-    group from: :crd_server_demonstrate_hook_response
-
-    group from: :crd_server_hooks
-  end
-end

data/lib/davinci_crd_test_kit/routes/cds_services_discovery_handler.rb

@@ -1,18 +0,0 @@
-module DaVinciCRDTestKit
-  module Routes
-    class CDSServicesDiscoveryHandler
-      def self.call(...)
-        new.call(...)
-      end
-
-      def self.cds_services
-        @cds_services ||= File.read(File.join(__dir__, 'cds-services.json'))
-      end
-
-      def call(_env)
-        # Check authorization header
-        [200, { 'Content-Type' => 'application/json' }, [self.class.cds_services]]
-      end
-    end
-  end
-end

data/lib/davinci_crd_test_kit/routes/hook_request_endpoint.rb

@@ -1,77 +0,0 @@
-require_relative '../mock_service_response'
-require_relative '../tags'
-module DaVinciCRDTestKit
-  class HookRequestEndpoint < Inferno::DSL::SuiteEndpoint
-    include DaVinciCRDTestKit::MockServiceResponse
-
-    def selected_response_types
-      @selected_response_types ||=
-        JSON.parse(result.input_json)
-          .find { |input| input['name'].include?('selected_response_types') }
-          &.dig('value')
-    end
-
-    def custom_response
-      @custom_response ||=
-        JSON.parse(result.input_json)
-          .find { |input| input['name'].include?('custom_response') }
-          &.dig('value')
-    end
-
-    def test_run_identifier
-      "#{hook_name} #{iss}"
-    end
-
-    def hook_name
-      @hook_name ||= request.params[:hook]
-    end
-
-    def iss
-      @iss ||=
-        begin
-          payload, = JWT.decode(token, nil, false)
-          payload['iss']
-        rescue JWT::DecodeError
-          nil
-        end
-    end
-
-    def token
-      @token ||= request.headers['authorization']&.delete_prefix('Bearer ')
-    end
-
-    def make_response
-      case hook_name
-      when 'appointment-book', 'encounter-start', 'encounter-discharge', 'order-select', 'order-sign', 'order-dispatch'
-        hook_response
-      else
-        response.status = 400
-        response.body = 'Invalid Request: Request did not contain a valid hook in the `hook` field.'
-      end
-    end
-
-    def tags
-      case hook_name
-      when 'appointment-book'
-        [APPOINTMENT_BOOK_TAG]
-      when 'encounter-start'
-        [ENCOUNTER_START_TAG]
-      when 'encounter-discharge'
-        [ENCOUNTER_DISCHARGE_TAG]
-      when 'order-select'
-        [ORDER_SELECT_TAG]
-      when 'order-sign'
-        [ORDER_SIGN_TAG]
-      when 'order-dispatch'
-        [ORDER_DISPATCH_TAG]
-      else
-        response.status = 400
-        response.body = 'Invalid Request: Request did not contain a valid hook in the `hook` field.'
-      end
-    end
-
-    def name
-      hook_name.gsub('-', '_')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/routes/jwk_set_endpoint_handler.rb

@@ -1,15 +0,0 @@
-require_relative '../jwks'
-
-module DaVinciCRDTestKit
-  module Routes
-    class JWKSetEndpointHandler
-      def self.call(...)
-        new.call(...)
-      end
-
-      def call(_env)
-        [200, { 'Content-Type' => 'application/json' }, [JWKS.jwks_json]]
-      end
-    end
-  end
-end

data/lib/davinci_crd_test_kit/server_appointment_book_group.rb

@@ -1,176 +0,0 @@
-require_relative 'server_tests/service_call_test'
-require_relative 'server_tests/service_response_validation_test'
-require_relative 'server_tests/card_optional_fields_validation_test'
-require_relative 'server_tests/external_reference_card_validation_test'
-require_relative 'server_tests/coverage_information_system_action_received_test'
-require_relative 'server_tests/coverage_information_system_action_validation_test'
-require_relative 'server_tests/instructions_card_received_test'
-require_relative 'server_tests/service_request_required_fields_validation_test'
-require_relative 'server_tests/service_request_optional_fields_validation_test'
-require_relative 'server_tests/service_request_context_validation_test'
-require_relative 'server_tests/form_completion_response_validation_test'
-require_relative 'server_tests/launch_smart_app_card_validation_test'
-require_relative 'server_tests/create_or_update_coverage_info_response_validation_test'
-require_relative 'tags'
-
-module DaVinciCRDTestKit
-  class ServerAppointmentBookGroup < Inferno::TestGroup
-    title 'appointment-book'
-    id :crd_server_appointment_book
-    description %(
-      This group of tests invokes the appointment-book hook and ensures that
-      the user-provided requests are valid as per the requirements described
-      in the [CRD IG section on appointment-book hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#appointment-book)
-      and the [CDS Hooks specification section on appointment-book context](https://cds-hooks.hl7.org/hooks/appointment-book/2023SepSTU1Ballot/appointment-book/).
-      It also ensures that the contents of the server's response are valid as per the requirements described in
-      the [CRD IG section on appointment-book hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#appointment-book)
-      and the [CDS Hooks section on CDS Service Response](https://cds-hooks.hl7.org/2.0/#cds-service-response).
-
-      The [CRD IG section on appointment-book hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#appointment-book)
-      states that "servers SHALL, at minimum, support returning and processing the Coverage Information
-      system action for all invocations of this hook."
-
-      This group includes tests to validate the following CRD response types:
-      - [Coverage Information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#coverage-information)
-      - [Create or update coverage information](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#create-or-update-coverage-information)\
-      - optional
-      - [External Reference](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#external-reference) - optional
-      - [Instructions](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#instructions) - optional
-      - [Launch SMART application](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#launch-smart-application) -
-      optional
-      - [Request form completion](https://hl7.org/fhir/us/davinci-crd/STU2/cards.html#request-form-completion) -
-      optional
-    )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@164', 'hl7.fhir.us.davinci-crd_2.0.1@168',
-                          'hl7.fhir.us.davinci-crd_2.0.1@170', 'hl7.fhir.us.davinci-crd_2.0.1@184'
-
-    config options: { hook_name: APPOINTMENT_BOOK_TAG }
-    run_as_group
-
-    test from: :crd_service_call_test,
-         config: {
-           inputs: {
-             service_ids: {
-               name: :appointment_book_service_ids,
-               title: 'Service id for the service that implements the `appointment-book` hook'
-             },
-             service_request_bodies: {
-               name: :appointment_book_request_bodies,
-               title: 'Request body or bodies for invoking the `appointment-book` hook'
-             }
-           }
-         }
-
-    test from: :crd_service_request_required_fields_validation,
-         config: {
-           outputs: {
-             contexts: {
-               name: :appointment_book_contexts
-             }
-           }
-         }
-    test from: :crd_service_request_context_validation,
-         config: {
-           inputs: {
-             contexts: {
-               name: :appointment_book_contexts
-             }
-           }
-         }
-    test from: :crd_service_request_optional_fields_validation
-    test from: :crd_service_response_validation,
-         config: {
-           outputs: {
-             valid_cards: {
-               name: :appointment_book_valid_cards
-             },
-             valid_system_actions: {
-               name: :appointment_book_valid_system_actions
-             }
-           }
-         }
-    test from: :crd_card_optional_fields_validation,
-         config: {
-           inputs: {
-             valid_cards: {
-               name: :appointment_book_valid_cards
-             }
-           },
-           outputs: {
-             valid_cards_with_links: {
-               name: :appointment_book_valid_cards_with_links
-             },
-             valid_cards_with_suggestions: {
-               name: :appointment_book_valid_cards_with_suggestions
-             }
-           }
-         }
-    test from: :crd_external_reference_card_validation,
-         config: {
-           inputs: {
-             valid_cards_with_links: {
-               name: :appointment_book_valid_cards_with_links
-             }
-           }
-         }
-    test from: :crd_launch_smart_app_card_validation,
-         config: {
-           inputs: {
-             valid_cards_with_links: {
-               name: :appointment_book_valid_cards_with_links
-             }
-           }
-         }
-    test from: :crd_valid_instructions_card_received,
-         config: {
-           inputs: {
-             valid_cards: {
-               name: :appointment_book_valid_cards
-             }
-           }
-         }
-    test from: :crd_coverage_info_system_action_received,
-         config: {
-           inputs: {
-             valid_system_actions: {
-               name: :appointment_book_valid_system_actions
-             }
-           },
-           outputs: {
-             coverage_info: {
-               name: :appointment_book_coverage_info
-             }
-           }
-         }
-    test from: :crd_coverage_info_system_action_validation,
-         config: {
-           inputs: {
-             coverage_info: {
-               name: :appointment_book_coverage_info
-             }
-           }
-         }
-    test from: :crd_request_form_completion_response_validation,
-         config: {
-           inputs: {
-             valid_system_actions: {
-               name: :appointment_book_valid_system_actions
-             },
-             valid_cards_with_suggestions: {
-               name: :appointment_book_valid_cards_with_suggestions
-             }
-           }
-         }
-    test from: :crd_create_or_update_coverage_info_response_validation,
-         config: {
-           inputs: {
-             valid_system_actions: {
-               name: :appointment_book_valid_system_actions
-             },
-             valid_cards_with_suggestions: {
-               name: :appointment_book_valid_cards_with_suggestions
-             }
-           }
-         }
-  end
-end

data/lib/davinci_crd_test_kit/server_demonstrate_hook_response_group.rb

@@ -1,77 +0,0 @@
-require_relative 'server_tests/service_call_test'
-require_relative 'server_tests/service_request_required_fields_validation_test'
-require_relative 'server_tests/service_request_context_validation_test'
-require_relative 'server_tests/service_response_validation_test'
-require_relative 'tags'
-
-module DaVinciCRDTestKit
-  class ServerDemonstrateHookResponseGroup < Inferno::TestGroup
-    title 'Demonstrate A Hook Response'
-    id :crd_server_demonstrate_hook_response
-    description %(
-      This group of tests allows the system to demonstrate its ability to respond to a CRD Hook invocation
-      and return a valid response. Inferno will use the provided request body and will either use the provided service
-      id or infer one from the hook indicated in the request and the server's discovery response.
-      It ensures that the user-provided request and the server's response are both
-      valid as per the requirements described in the [CRD IG section](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html)
-      and the [CDS Hooks](https://cds-hooks.hl7.org/) hook specification for the corresponding hook.
-    )
-
-    config options: { hook_name: ANY_HOOK_TAG }
-    run_as_group
-
-    test from: :crd_service_call_test,
-         config: {
-           inputs: {
-             service_ids: {
-               name: :any_hook_service_ids,
-               title: 'Service id to use for the "Demonstrate a Hook Response" 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: :any_hook_request_body,
-               title: 'Request body to use for the "Demonstrate a Hook Response" 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.
-              )
-             }
-           }
-         }
-
-    test from: :crd_service_request_required_fields_validation,
-         config: {
-           outputs: {
-             contexts: {
-               name: :any_hook_contexts
-             }
-           }
-         }
-    test from: :crd_service_request_context_validation,
-         config: {
-           inputs: {
-             contexts: {
-               name: :any_hook_contexts
-             },
-             request_body: {
-               name: :any_hook_request_body
-             }
-           }
-         }
-    test from: :crd_service_response_validation,
-         config: {
-           outputs: {
-             valid_cards: {
-               name: :any_hook_valid_cards
-             },
-             valid_system_actions: {
-               name: :any_hook_valid_system_actions
-             }
-           }
-         }
-  end
-end

data/lib/davinci_crd_test_kit/server_discovery_group.rb

@@ -1,60 +0,0 @@
-require 'tls_test_kit'
-require_relative 'server_tests/discovery_endpoint_test'
-require_relative 'server_tests/discovery_services_validation_test'
-
-module DaVinciCRDTestKit
-  class ServerDiscoveryGroup < Inferno::TestGroup
-    title 'Discovery'
-    id :crd_server_discovery_group
-    description %(
-      # Background
-
-      The #{title} Group checks for a CDS Service's Discovery endpoint as described by the
-      [CDS Hooks Specification](https://cds-hooks.hl7.org/2.0/#discovery).
-      A CDS Service is discoverable via a stable endpoint by CDS Clients. The Discovery endpoint
-      includes information such as a description of the CDS Service, when it should be invoked,
-      and any data that is requested to be prefetched.
-      The Discovery endpoint SHALL always be available at `{baseUrl}/cds-services`.
-
-      # Test Methodology
-
-      This test sequence accesses the CRD server Discovery endpoint at /cds-services using a GET request.
-      It parses the response and verifies that:
-      - The Discovery endpoint is TLS secured.
-      - The Discovery endpoint is available at `{baseURL}/cds-services`.
-      - Each CDS Service in the response contains the required fields as specified in the [CDS Hooks Spec](https://cds-hooks.hl7.org/2.0/#response).
-
-      It collects the following information that is saved in the testing session for use by later tests:
-      - List of supported CDS Services/Hooks
-      - List of service IDs for each supported Hook.
-    )
-
-    run_as_group
-
-    test from: :tls_version_test do
-      title 'CRD Server is secured by transport layer security'
-      description <<~DESCRIPTION
-        Under [Privacy, Security, and Safety](https://hl7.org/fhir/us/davinci-crd/STU2/security.html),
-        the CRD Implementation Guide imposes the following rule about TLS:
-
-        As per the [CDS Hook specification](https://cds-hooks.hl7.org/2.0/#security-and-safety),
-        communications between CRD Clients and CRD Servers SHALL
-        use TLS. Mutual TLS is not required by this specification but is permitted. CRD Servers and
-        CRD Clients SHOULD enforce a minimum version and other TLS configuration requirements based
-        on HRex rules for PHI exchange.
-
-        This test verifies that the CRD server is using TLS 1.2 or higher.
-      DESCRIPTION
-      verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@89'
-      id :crd_server_tls_version_stu2
-
-      config(
-        options: { minimum_allowed_version: OpenSSL::SSL::TLS1_2_VERSION },
-        inputs: { url: { name: :base_url } }
-      )
-    end
-
-    test from: :crd_discovery_endpoint_test
-    test from: :crd_discovery_services_validation
-  end
-end