davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/client_tests/order_select_receive_request_test.rb

@@ -1,98 +0,0 @@
-require_relative '../urls'
-
-module DaVinciCRDTestKit
-  class OrderSelectReceiveRequestTest < Inferno::Test
-    include URLs
-
-    id :crd_order_select_request
-    title 'Request received for order-select hook'
-    description %(
-      This test waits for multiple incoming [order-select](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-select)
-      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@209', '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_select_selected_response_types,
-          title: 'Response types to return from order-select 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'
-              },
-              {
-                label: 'Propose Alternate Request',
-                value: 'propose_alternate_request'
-              },
-              {
-                label: 'Additional Orders as Companions/Prerequisites',
-                value: 'companions_prerequisites'
-              }
-            ]
-          }
-    input :order_select_custom_response,
-          title: 'Custom response for order-select 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-select #{cds_jwt_iss}",
-        message: %(
-          **Order Select CDS Service Test**:
-
-          Invoke the order-select hook and send requests to:
-
-          `#{order_select_url}`
-
-          Inferno will process the requests and return CDS cards if successful.
-
-          [Click here](#{resume_pass_url}?token=order-select%20#{cds_jwt_iss}) when you have finished submitting
-          requests.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/order_sign_receive_request_test.rb

@@ -1,101 +0,0 @@
-require_relative '../urls'
-
-module DaVinciCRDTestKit
-  class OrderSignReceiveRequestTest < Inferno::Test
-    include URLs
-
-    id :crd_order_sign_request
-    title 'Request received for order-sign hook'
-    description %(
-        This test waits for multiple incoming [order-sign](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-sign)
-        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@218', 'hl7.fhir.us.davinci-crd_2.0.1@225',
-                          '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_sign_selected_response_types,
-          title: 'Response types to return from order-sign 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_sign_custom_response,
-          title: 'Custom response for order-sign 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-sign #{cds_jwt_iss}",
-        message: %(
-          **Order Sign CDS Service Test**:
-
-          Invoke the order-sign hook and send requests to:
-
-          `#{order_sign_url}`
-
-          Inferno will process the requests and return CDS cards if successful.
-
-          [Click here](#{resume_pass_url}?token=order-sign%20#{cds_jwt_iss}) when you have finished submitting requests.
-        )
-      )
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/retrieve_jwks_test.rb

@@ -1,105 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class RetrieveJWKSTest < Inferno::Test
-    include ClientHookRequestValidation
-
-    id :crd_retrieve_jwks
-    title 'JWKS can be retrieved'
-    description %(
-        Verify that the JWKS can be retrieved from the JWKS uri if it is present in the `jku` field within the JWT token
-        header. As per the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#trusting-cds-clients), if the jku
-        header field is omitted, the CDS Client and CDS Service SHALL communicate the JWK Set out-of-band. Therefore,
-        if the client does not make their keys publicly available via a uri in the `jku` field, the user must
-        submit the jwk_set as an input to the test.
-      )
-
-    input :auth_token_headers_json
-    input :cds_jwk_set,
-          title: 'CRD JSON Web Key Set (JWKS)',
-          type: 'textarea',
-          description: %(
-            The client's registered JWK Set containing it's public key, either
-            as a publicly accessible url containing the JWKS, or the raw JWKS.
-            Run or re-run the **Client Registration** group to set or
-            change this value. Used if the `jku` header is not found in the auth token jwt.
-          ),
-          locked: true,
-          optional: true
-    output :crd_jwks_json, :crd_jwks_keys_json
-
-    run do
-      auth_token_headers = JSON.parse(auth_token_headers_json)
-      skip_if auth_token_headers.empty?, 'No Authorization tokens produced from the previous test.'
-
-      crd_jwks_json = []
-      crd_jwks_keys_json = []
-      auth_token_headers.each_with_index do |token_header, index|
-        @request_number = index + 1
-
-        jku = JSON.parse(token_header)['jku']
-        if jku.present?
-          get(jku)
-
-          if response[:status] != 200
-            add_message('error', %(
-                        #{request_number}Unexpected response status: expected 200, but received
-                        #{response[:status]}))
-            next
-          end
-
-          @request_number = index + 1
-          jwks = json_parse(response[:body])
-          next if jwks.blank?
-
-          crd_jwks_json << response[:body]
-
-          jwks = JSON.parse(response[:body])
-        else
-          skip_if cds_jwk_set.blank?,
-                  %(#{request_number}JWK Set must be inputted if Client's JWK Set is not available via a URL
-                  identified by the jku header field)
-
-          jwks = JSON.parse(cds_jwk_set)
-        end
-
-        keys = jwks['keys']
-        unless keys.is_a?(Array)
-          add_message('error', "#{request_number}JWKS `keys` field must be an array")
-          next
-        end
-
-        if keys.blank?
-          add_message('error', "#{request_number}The JWK set returned contains no public keys")
-          next
-        end
-
-        keys.each do |jwk|
-          JWT::JWK.import(jwk.deep_symbolize_keys)
-        rescue StandardError
-          add_message('error', "#{request_number}Invalid JWK: #{jwk.to_json}")
-        end
-
-        kid_presence = keys.all? { |key| key['kid'].present? }
-        if kid_presence.blank?
-          add_message('error',
-                      "#{request_number}`kid` field must be present in each key if JWKS contains multiple keys")
-          next
-        end
-
-        kid_uniqueness = keys.map { |key| key['kid'] }.uniq.length == keys.length
-        if kid_uniqueness.blank?
-          add_message('error', "#{request_number}`kid` must be unique within the client's JWK Set.")
-          next
-        end
-
-        crd_jwks_keys_json << keys.to_json
-      end
-
-      output crd_jwks_json: crd_jwks_json.to_json,
-             crd_jwks_keys_json: crd_jwks_keys_json.to_json
-
-      no_error_validation('Retrieving JWKS failed.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/submitted_response_validation.rb

@@ -1,48 +0,0 @@
-module DaVinciCRDTestKit
-  class SubmittedResponseValidationTest < Inferno::Test
-    include CardsValidation
-
-    title 'Custom CDS Service Response is valid'
-    description %(
-      If a custom CDS Service response is provided for Inferno to return when simulating the CRD Server's
-      hook response, this test will check that it is a valid CRD hook response.
-    )
-    id :crd_submitted_response_validation
-
-    input :custom_response, optional: true
-
-    def hook_name
-      config.options[:hook_name]
-    end
-
-    def response_label(_index = nil)
-      'Custom response'
-    end
-
-    def valid_cards
-      @valid_cards ||= []
-    end
-
-    def validate_system_actions(system_actions)
-      return if system_actions.nil?
-
-      system_actions.each do |action|
-        action_fields_validation(action)
-      end
-    end
-
-    run do
-      omit_if custom_response.blank?, 'Custom response was not provided'
-
-      assert_valid_json custom_response
-
-      custom_response_hash = JSON.parse(custom_response)
-
-      perform_cards_validation(custom_response_hash['cards'])
-
-      validate_system_actions(custom_response_hash['systemActions'])
-
-      no_error_validation('Custom response is not valid. Check messages for issues found.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/token_header_test.rb

@@ -1,65 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class TokenHeaderTest < Inferno::Test
-    include ClientHookRequestValidation
-
-    id :crd_token_header
-    title 'Authorization token header contains required information'
-    description %(
-      Verify that the JWT header contains the header fields required by the [CDS hooks spec](https://cds-hooks.hl7.org/2.0#trusting-cds-clients).
-      The `alg`, `kid`, and `typ` fields are required. This test also verifies that the `typ` field is set to `JWT` and
-      that the key used to sign the token can be identified in the JWKS.
-    )
-
-    input :auth_token_headers_json, :crd_jwks_keys_json
-    output :auth_tokens_jwk_json
-
-    run do
-      auth_token_headers = JSON.parse(auth_token_headers_json)
-      crd_jwks_keys = JSON.parse(crd_jwks_keys_json)
-      skip_if auth_token_headers.empty?, 'No Authorization tokens produced from the previous tests.'
-      skip_if crd_jwks_keys.empty?, 'No JWKS keys produced from the previous test.'
-
-      auth_tokens_jwk_json = []
-      auth_token_headers.each_with_index do |token_header, index|
-        @request_number = index + 1
-
-        header = JSON.parse(token_header)
-        algorithm = header['alg']
-
-        add_message('error', "#{request_number}Token header must have the `alg` field") if algorithm.blank?
-
-        add_message('error', "#{request_number}Token header `alg` field cannot be set to none") if algorithm == 'none'
-
-        if header['typ'].blank?
-          add_message('error', "#{request_number}Token header must have the `typ` field")
-        elsif header['typ'] != 'JWT'
-          add_message('error', %(
-                      #{request_number}Token header `typ` field must be set to 'JWT', instead was
-                      #{header['typ']}))
-        end
-
-        if header['kid'].blank?
-          add_message('error', "#{request_number}Token header must have the `kid` field")
-          next
-        end
-
-        kid = header['kid']
-        keys = JSON.parse(crd_jwks_keys[index])
-
-        jwk = keys.find { |key| key['kid'] == kid }
-        if jwk.blank?
-          add_message('error', "#{request_number}JWKS did not contain a public key with an id of `#{kid}`")
-          next
-        end
-
-        auth_tokens_jwk_json << jwk.to_json
-      end
-
-      output auth_tokens_jwk_json: auth_tokens_jwk_json.to_json
-
-      no_error_validation('Token headers missing required information.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/token_payload_test.rb

@@ -1,78 +0,0 @@
-require_relative '../client_hook_request_validation'
-
-module DaVinciCRDTestKit
-  class TokenPayloadTest < Inferno::Test
-    include ClientHookRequestValidation
-    include URLs
-    id :crd_token_payload
-    title 'Authorization token payload has required claims and a valid signature'
-    description %(
-      Verify that the JWT payload contains the payload fields required by the
-      [CDS hooks spec](https://cds-hooks.hl7.org/2.0#trusting-cds-clients).
-      The `iss`, `aud`, `exp`, `iat`, and `jti` claims are required.
-      Additionally:
-
-      - `iss` must match the `issuer` from the **CRD JWT Issuer** input
-      - `aud` must match the URL of the CDS Service endpoint being invoked
-      - `exp` must represent a time in the future
-      - `jti` must be a non-blank string that uniquely identifies this authentication JWT
-    )
-
-    REQUIRED_CLAIMS = ['iss', 'aud', 'exp', 'iat', 'jti'].freeze
-
-    def required_claims
-      REQUIRED_CLAIMS.dup
-    end
-
-    def hook_url
-      base_url + config.options[:hook_path]
-    end
-
-    input :auth_tokens,
-          :auth_tokens_jwk_json,
-          :cds_jwt_iss
-
-    run do
-      auth_tokens_list = JSON.parse(auth_tokens)
-      auth_tokens_jwk = JSON.parse(auth_tokens_jwk_json)
-      skip_if auth_tokens_list.empty?, 'No Authorization tokens produced from the previous tests.'
-      skip_if auth_tokens_jwk.empty?, 'No Authorization token JWK produced from the previous test.'
-
-      auth_tokens_jwk.each_with_index do |auth_token_jwk, index|
-        @request_number = index + 1
-
-        begin
-          jwk = JSON.parse(auth_token_jwk).deep_symbolize_keys
-
-          payload, =
-            JWT.decode(
-              auth_tokens_list[index],
-              JWT::JWK.import(jwk).public_key,
-              true,
-              algorithms: [jwk[:alg]],
-              exp_leeway: 60,
-              iss: cds_jwt_iss,
-              aud: hook_url,
-              verify_not_before: false,
-              verify_iat: false,
-              verify_jti: true,
-              verify_iss: true,
-              verify_aud: true
-            )
-        rescue StandardError => e
-          add_message('error', "#{request_number}Token validation error: #{e.message}")
-          next
-        end
-
-        missing_claims = required_claims - payload.keys
-        missing_claims_string = missing_claims.map { |claim| "`#{claim}`" }.join(', ')
-
-        unless missing_claims.empty?
-          add_message('error', "#{request_number}JWT payload missing required claims: #{missing_claims_string}")
-          next
-        end
-      end
-      no_error_validation('Token payload is missing required claims or does not have a valid signiture.')
-    end
-  end
-end

data/lib/davinci_crd_test_kit/crd_client_suite.rb

@@ -1,193 +0,0 @@
-require_relative 'client_fhir_api_group'
-require_relative 'client_hooks_group'
-require_relative 'client_registration_group'
-require_relative 'routes/cds_services_discovery_handler'
-require_relative 'tags'
-require_relative 'urls'
-require_relative 'crd_options'
-require_relative 'routes/hook_request_endpoint'
-require_relative 'ext/inferno_core/runnable'
-
-module DaVinciCRDTestKit
-  class CRDClientSuite < Inferno::TestSuite
-    id :crd_client
-    title 'Da Vinci CRD Client Test Suite'
-    description <<~DESCRIPTION
-      The Da Vinci CRD Client Test Suite tests the conformance of client 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 two groups of tests. The Hooks group receives and
-      responds to incoming CDS Hooks requests from CRD clients. The FHIR API
-      group makes FHIR requests to CRD Clients to verify that they support the
-      FHIR interactions defined in the implementation guide.
-
-      ## CDS Services
-      This suite provides basic CDS services for [the six hooks contained in the
-      implementation
-      guide](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html). The discovery
-      endpoint is located at:
-
-      * `#{Inferno::Application['base_url']}/custom/#{id}/cds-services`
-
-      ## SMART App Launch
-      Use this information when registering Inferno as a SMART App:
-
-      * Launch URI: `#{SMARTAppLaunch::AppLaunchTest.config.options[:launch_uri] ||
-                       "#{Inferno::Application['base_url']}/custom/smart/launch"}`
-      * Redirect URI: `#{SMARTAppLaunch::AppRedirectTest.config.options[:redirect_uri] ||
-                         "#{Inferno::Application['base_url']}/custom/smart/redirect"}`
-
-      If a client receives a SMART App Launch card in a response and would like
-      to test their ability to launch Inferno as a SMART App, first run the
-      SMART on FHIR Discovery and SMART EHR Launch groups under FHIR API >
-      Authorization. When running the SMART EHR Launch group, Inferno will wait
-      for the incoming SMART App Launch request, and this is the time to perform
-      the launch from the client being tested.
-
-      ## Running the Tests
-      If you would like to try out the tests against [the public CRD reference
-      client](https://crd-request-generator.davinci.hl7.org/), you can do so by:
-      1. Selecting the *CRD Request Generator RI* option from the Preset
-         dropdown in the upper left.
-      2. Selecting the *order-sign* hook group on the left menu.
-      3. Clicking on the *RUN TESTS* button in the upper right.
-      4. Clicking the *Submit* button at the bottom of the input dialog.
-      5. Follow the instructions in the wait dialog.
-      6. Open the reference client in another tab/browser.
-      7. Update the *CRD Server* field in the client configuration to point to
-         the discovery endpoint of this suite provided above, and the *Order
-         Sign Rest End Point*
-         to the service id provided in the wait dialog.
-      8. Select the patient data to be used to form the request, then submit the
-         request.
-
-      You can run these tests using your own client by updating the inputs with
-      your own data.
-
-      Note that:
-      - You can only sequentially *RUN ALL TESTS* if your system supports all
-        hooks.
-      - Systems are not expected to pass the *FHIR RESTful Capabilities* tests
-        based on the provided inputs, as the resource might not exist on the
-        client's FHIR server.
-
-      ## Running the Tests aginst the Server Suite
-
-      You can also run these tests against the Inferno CRD Server test suite.
-      The server suite will not render cards like a real CRD client would do,
-      but will simulate and verify the interactions between the client and
-      server.
-
-      1. Start a "Da Vinci CRD Client Test Suite" session.
-      1. Choose the "Inferno CRD Server Suite" preset from the drop down in the upper left.
-      1. Run the Client Registration test group. It should pass.
-      1. Run the Hooks > Appointment Book test group leaving the inputs as is. A
-         "User Action Dialog" will appear indicating that Inferno is waiting for the
-         `appointment-book` hook invocation.
-      1. In another tab, start a "Da Vinci CRD Server Test Suite" session.
-      1. Choose the "Inferno CRD Client Suite" preset from the drop down in the upper left.
-      1. Run the Discovery test group. It should pass.
-      1. Run the Demonstrate A Hook Response test. It should pass
-      1. Return to the client suite and click the link to continue the tests.
-      1. When the attestation wait dialog appears, return to the server tests and look in test
-         **2.04** "All service responses contain valid cards and optional systemActions"
-         for the CDS hooks request made and look at the response to verify that the
-         indicate cards are present. Attest accordingly in the client suite to complete the tests.
-
-      ## Limitations
-      The test suite does not implement any sort of payer business logic, so the
-      responses to hook calls are simple hard-coded responses. Hook
-      configuration is not tested.
-    DESCRIPTION
-
-    suite_summary <<~SUMMARY
-      The Da Vinci CRD Client Test Suite tests the conformance of client 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: 'Client'
-      }
-    )
-
-    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
-
-    suite_option :smart_app_launch_version,
-                 title: 'SMART App Launch Version',
-                 list_options: [
-                   {
-                     label: 'SMART App Launch 1.0.0',
-                     value: CRDOptions::SMART_1
-                   },
-                   {
-                     label: 'SMART App Launch 2.0.0',
-                     value: CRDOptions::SMART_2
-                   }
-                 ]
-
-    def self.extract_token_from_query_params(request)
-      request.query_parameters['token']
-    end
-
-    route :get, '/cds-services', Routes::CDSServicesDiscoveryHandler
-    # TODO
-    # route :post, '/cds-services/:cds-service_id', cds_service_handler
-
-    allow_cors APPOINTMENT_BOOK_PATH, ENCOUNTER_START_PATH, ENCOUNTER_DISCHARGE_PATH, ORDER_DISPATCH_PATH,
-               ORDER_SELECT_PATH, ORDER_SIGN_PATH
-    suite_endpoint :post, APPOINTMENT_BOOK_PATH, HookRequestEndpoint
-    suite_endpoint :post, ENCOUNTER_START_PATH, HookRequestEndpoint
-    suite_endpoint :post, ENCOUNTER_DISCHARGE_PATH, HookRequestEndpoint
-    suite_endpoint :post, ORDER_DISPATCH_PATH, HookRequestEndpoint
-    suite_endpoint :post, ORDER_SELECT_PATH, HookRequestEndpoint
-    suite_endpoint :post, ORDER_SIGN_PATH, HookRequestEndpoint
-
-    resume_test_route :get, RESUME_PASS_PATH do |request|
-      CRDClientSuite.extract_token_from_query_params(request)
-    end
-    resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
-      CRDClientSuite.extract_token_from_query_params(request)
-    end
-
-    group do
-      id :crd_client_hook_invocation
-      title 'Hook Invocation'
-      description %(
-        This groups checks that the system can register as a CDS Client with
-        Inferno's simulated CRD Server and make hook invocations.
-      )
-
-      group from: :crd_client_registration
-      group from: :crd_client_hooks
-    end
-
-    group from: :crd_client_fhir_api
-  end
-end