davinci_crd_test_kit 0.12.2 → 0.14.0

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_search_test.rb

@@ -1,232 +0,0 @@
-module DaVinciCRDTestKit
-  class ClientFHIRApiSearchTest < Inferno::Test
-    id :crd_client_fhir_api_search_test
-    title 'Search Interaction'
-    description %(
-        Verify that the CRD client supports the specified search interaction for the given resource. The capabilities
-        required by each resource can be found here: https://hl7.org/fhir/us/davinci-crd/CapabilityStatement-crd-client.html#resourcesSummary1
-      )
-
-    input :search_param_values,
-          optional: true
-
-    attr_accessor :successful_search
-
-    def resource_type
-      config.options[:resource_type]
-    end
-
-    def search_type
-      config.options[:search_type]
-    end
-
-    def include_searches
-      ['organization_include', 'practitioner_include', 'location_include']
-    end
-
-    def reference_search_parameters
-      ['organization', 'practitioner', 'patient']
-    end
-
-    def bad_resource_id_message(expected_id, actual_id)
-      "Expected resource to have id: `#{expected_id}`, but found `#{actual_id}`"
-    end
-
-    def perform_fhir_search(search_params, tags)
-      fhir_search(resource_type, params: search_params, tags:)
-      assert_response_status(200)
-      assert_resource_type(:bundle)
-      resource
-    end
-
-    def status_search_result_check(bundle, status)
-      return if bundle.entry.empty?
-
-      self.successful_search = true
-
-      bundle.entry
-        .reject { |entry| entry&.resource&.resourceType == 'OperationOutcome' }
-        .map(&:resource)
-        .each do |resource|
-          assert_resource_type(resource_type, resource:)
-          assert(resource.status == status, %(
-            Each #{resource_type} resource in search result bundle should have a status of `#{status}`, instead got:
-            `#{resource.status}` for resource with id: `#{resource.id}`
-            ))
-        end
-    end
-
-    def check_id_search_result_entry(bundle_entry, search_id, entry_resource_type)
-      assert_resource_type(entry_resource_type, resource: bundle_entry)
-
-      assert bundle_entry.id.present?, "Expected id field in returned #{entry_resource_type} resource"
-
-      assert bundle_entry.id == search_id,
-             bad_resource_id_message(search_id, bundle_entry.id)
-    end
-
-    def id_search_result_check(bundle, search_id)
-      warning do
-        assert bundle.entry.any?,
-               "Search result bundle is empty for #{resource_type} _id search with an id of `#{search_id}`"
-      end
-      return if bundle.entry.empty?
-
-      self.successful_search = true
-
-      bundle.entry
-        .reject { |entry| entry&.resource&.resourceType == 'OperationOutcome' }
-        .map(&:resource)
-        .each do |resource|
-          check_id_search_result_entry(resource, search_id, resource_type)
-        end
-    end
-
-    def check_include_reference(base_resource_entry, include_resource_id, include_resource_type)
-      base_resource_references = Array.wrap(get_reference_field(include_resource_type, base_resource_entry)).compact
-
-      assert(base_resource_references.present?, %(
-             #{resource_type} resource with id #{base_resource_entry.id} did not include the field that references a
-             #{include_resource_type} resource}
-             ))
-
-      base_resource_reference_match_found = base_resource_references.any? do |base_resource_reference|
-        base_resource_reference.reference_id == include_resource_id
-      end
-
-      assert(base_resource_reference_match_found, %(
-        The #{resource_type} resource in search result bundle with id #{base_resource_entry.id} did not have a
-        #{include_resource_type} reference with an id of `#{include_resource_id}`.`
-      ))
-    end
-
-    def include_search_result_check(bundle, search_id, included_resource_type) # rubocop:disable Metrics/CyclomaticComplexity
-      warning do
-        assert bundle.entry.any?,
-               "Search result bundle is empty for #{resource_type} _include #{search_type} search with an id
-               of `#{search_id}`"
-      end
-      return if bundle.entry.empty?
-
-      self.successful_search = true
-
-      base_resource_entry_list = bundle.entry.select do |entry|
-        entry.resource&.resourceType == resource_type
-      end
-
-      assert(base_resource_entry_list.length == 1, %(
-        The #{included_resource_type} _include search for #{resource_type} resource with id #{search_id}
-        should include exactly 1 #{resource_type} resource, instead got #{base_resource_entry_list.length}.
-      ))
-
-      base_resource_entry = base_resource_entry_list.first.resource
-
-      bundle.entry
-        .map(&:resource)
-        .each do |resource|
-          entry_resource_type = resource.resourceType
-
-          if entry_resource_type == resource_type
-            check_id_search_result_entry(resource, search_id, entry_resource_type)
-          elsif entry_resource_type != 'OperationOutcome'
-            entry_resource_type = included_resource_type.capitalize
-            assert_resource_type(entry_resource_type, resource:)
-
-            included_resource_id = resource.id
-            assert included_resource_id.present?, "Expected id field in returned #{entry_resource_type} resource"
-            check_include_reference(base_resource_entry, included_resource_id, included_resource_type)
-          end
-        end
-    end
-
-    def get_reference_field(reference_type, entry)
-      case reference_type
-      when 'patient'
-        entry.beneficiary
-      when 'practitioner'
-        entry.practitioner
-      when 'organization'
-        if resource_type == 'Encounter'
-          entry.serviceProvider
-        else
-          entry.organization
-        end
-      when 'location'
-        locations = entry.location
-        locations.map(&:location)
-      end
-    end
-
-    def reference_search_result_check(bundle, reference_id, reference_type)
-      warning do
-        assert bundle.entry.any?, %(
-               Search result bundle is empty for #{resource_type} #{reference_type} search with a #{reference_type} id
-               `#{reference_id}`
-        )
-      end
-      return if bundle.entry.empty?
-
-      self.successful_search = true
-
-      bundle.entry
-        .reject { |entry| entry&.resource&.resourceType == 'OperationOutcome' }
-        .map(&:resource)
-        .each do |resource|
-          assert_resource_type(resource_type, resource:)
-
-          entry_reference_field = get_reference_field(reference_type, resource)
-          assert(
-            entry_reference_field.present?,
-            %(
-              #{resource_type} resource with id #{resource.id} did not include the field that references
-              a #{reference_type} resource
-            )
-          )
-
-          entry_reference_id = entry_reference_field.reference_id
-          assert(
-            entry_reference_id == reference_id,
-            %(
-              The #{resource_type} resource in search result bundle with id #{resource.id} should have a
-              #{reference_type} reference with an id of `#{reference_id}`, instead got: `#{entry_reference_id}`
-            )
-          )
-        end
-    end
-
-    run do
-      if search_type == 'status'
-        coverage_status = ['active', 'cancelled', 'draft', 'entered-in-error']
-        coverage_status.each do |status|
-          bundle = perform_fhir_search({ status: }, [resource_type, 'status_search'])
-          status_search_result_check(bundle, status)
-        end
-      else
-        skip_if search_param_values.blank?, 'No search parameters passed in, skipping test.'
-
-        search_id_list = search_param_values.split(',').map(&:strip)
-        search_id_list.each do |search_id|
-          if search_type == '_id'
-            bundle = perform_fhir_search({ _id: search_id }, [resource_type, 'id_search'])
-            id_search_result_check(bundle, search_id)
-          elsif reference_search_parameters.include?(search_type)
-            search_params = {}
-            search_params[search_type] = search_id
-            bundle = perform_fhir_search(search_params, [resource_type, "#{search_type}_search"])
-            reference_search_result_check(bundle, search_id, search_type)
-          elsif include_searches.include?(search_type)
-            include_resource_type = search_type.gsub('_include', '')
-            bundle = perform_fhir_search({ _id: search_id, _include: "#{resource_type}:#{include_resource_type}" },
-                                         [resource_type, "include_#{include_resource_type}_search"])
-            include_search_result_check(bundle, search_id, include_resource_type)
-          else
-            raise StandardError,
-                  'Passed in search_type does not match to any of the search types handled by this search test.'
-          end
-        end
-      end
-      skip_if !successful_search,
-              'No resources returned in any of the search result bundles.'
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_update_test.rb

@@ -1,41 +0,0 @@
-module DaVinciCRDTestKit
-  class ClientFHIRApiUpdateTest < Inferno::Test
-    id :crd_client_fhir_api_update_test
-    title 'Update Interaction'
-    description %(
-        Verify that the CRD client supports the update interaction for the given resource. The capabilities required by
-        each resource can be found here: https://hl7.org/fhir/us/davinci-crd/CapabilityStatement-crd-client.html#resourcesSummary1
-      )
-    verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@74'
-
-    input :update_resources,
-          type: 'textarea',
-          description:
-          'Provide a list of resources to update. e.g., [json_resource_1, json_resource_2]'
-
-    def resource_type
-      config.options[:resource_type]
-    end
-
-    run do
-      assert_valid_json(update_resources)
-      update_resources_list = JSON.parse(update_resources)
-      skip_if(!update_resources_list.is_a?(Array), 'Resources to update not inputted in list format, skipping test.')
-
-      valid_update_resources =
-        update_resources_list
-          .compact_blank
-          .map { |resource| FHIR.from_contents(resource.to_json) }
-          .select { |resource| resource.resourceType == resource_type }
-          .select { |resource| resource_is_valid?(resource:) }
-
-      skip_if(valid_update_resources.blank?,
-              %(No valid #{resource_type} resources were provided to send in Update requests, skipping test.))
-
-      valid_update_resources.each do |update_resource|
-        fhir_update(update_resource, update_resource.id)
-        assert_response_status([200, 201])
-      end
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_validation_test.rb

@@ -1,60 +0,0 @@
-module DaVinciCRDTestKit
-  class ClientFHIRApiValidationTest < Inferno::Test
-    id :crd_client_fhir_api_validation_test
-    title 'FHIR Resource Validation'
-    description %(
-        Verify that the given resources returned from the previous client API interactions are valid resources. Each
-        resource is validated against its corresponding [CRD resource profile](https://hl7.org/fhir/us/davinci-crd/STU2/artifacts.html).
-      )
-
-    def resource_type
-      config.options[:resource_type]
-    end
-
-    def structure_definition_map
-      {
-        'Practitioner' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-practitioner',
-        'PractitionerRole' => 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-practitionerrole',
-        'Patient' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-patient',
-        'Encounter' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-encounter',
-        'Coverage' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage',
-        'Device' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-device',
-        'Location' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-location',
-        'Organization' => 'http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-organization'
-      }.freeze
-    end
-
-    def profile_url
-      structure_definition_map[resource_type]
-    end
-
-    run do
-      load_tagged_requests(resource_type)
-      skip_if requests.empty?, 'No FHIR api requests were made'
-
-      requests.keep_if { |req| req.status == 200 }
-      skip_if(requests.blank?,
-              'There were no successful FHIR API requests made in previous tests to use in validation.')
-
-      validated_resources =
-        requests
-          .map(&:resource)
-          .compact
-          .flat_map { |resource| resource.is_a?(FHIR::Bundle) ? resource.entry.map(&:resource) : resource }
-          .select { |resource| resource.resourceType == resource_type }
-          .uniq { |resource| resource.to_reference.reference }
-          .each { |resource| resource_is_valid?(resource:, profile_url:) }
-
-      skip_if(validated_resources.blank?,
-              %(No #{resource_type} resources were returned from any of the FHIR API requests made in previous tests
-              that could be validated.))
-
-      validation_error_count = messages.count { |msg| msg[:type] == 'error' }
-      assert(validation_error_count.zero?,
-             %(#{validation_error_count}/#{validated_resources.length} #{resource_type} resources returned from previous
-             test's FHIR API requests failed validation.))
-
-      skip_if validated_resources.blank?, 'No FHIR resources were made in previous tests that could be validated.'
-    end
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_order_dispatch_group.rb

@@ -1,79 +0,0 @@
-require_relative 'order_dispatch_receive_request_test'
-require_relative 'client_display_cards_attest'
-require_relative 'decode_auth_token_test'
-require_relative 'hook_request_optional_fields_test'
-require_relative 'hook_request_required_fields_test'
-require_relative 'hook_request_valid_context_test'
-require_relative 'hook_request_valid_prefetch_test'
-require_relative 'retrieve_jwks_test'
-require_relative 'submitted_response_validation'
-require_relative 'token_header_test'
-require_relative 'token_payload_test'
-
-module DaVinciCRDTestKit
-  class ClientOrderDispatchGroup < Inferno::TestGroup
-    title 'order-dispatch'
-    id :crd_client_order_dispatch
-    description <<~DESCRIPTION
-      The order-dispatch hook fires when a practitioner is selecting a candidate performer for a pre-existing order
-      that was not tied to a specific performer. These tests are based on the following criteria:
-        * [CRD IG requirements for this hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-dispatch),
-        which includes the profiles that are expected to be used for the resources resolved to by `context`
-        FHIR ID fields
-        * Specific [order-dispatch `context` requirements](https://cds-hooks.hl7.org/hooks/order-dispatch/2023SepSTU1Ballot/order-dispatch/)
-        defined in the CDS Hooks specification
-
-      This version of the CRD implementation guide refers to version 1.0 of the hook.
-    DESCRIPTION
-
-    run_as_group
-
-    input_order :cds_jwt_iss, :cds_jwk_set
-
-    config(
-      inputs: {
-        auth_token_headers_json: { name: :order_dispatch_auth_token_headers_json },
-        auth_tokens: { name: :order_dispatch_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_dispatch_auth_tokens_jwk_json },
-        client_access_token: { name: :order_dispatch_client_access_token },
-        client_fhir_server: { name: :order_dispatch_client_fhir_server },
-        crd_jwks_keys_json: { name: :order_dispatch_crd_jwks_keys_json },
-        custom_response: { name: :order_dispatch_custom_response },
-        selected_response_types: { name: :order_dispatch_selected_response_types }
-      },
-      outputs: {
-        auth_token_headers_json: { name: :order_dispatch_auth_token_headers_json },
-        auth_token_payloads_json: { name: :order_dispatch_auth_token_payloads_json },
-        auth_tokens: { name: :order_dispatch_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_dispatch_auth_tokens_jwk_json },
-        client_access_token: { name: :order_dispatch_client_access_token },
-        client_fhir_server: { name: :order_dispatch_client_fhir_server },
-        crd_jwks_json: { name: :order_dispatch_crd_jwks_json },
-        crd_jwks_keys_json: { name: :order_dispatch_crd_jwks_keys_json }
-      },
-      options: {
-        hook_name: 'order-dispatch',
-        hook_path: ORDER_DISPATCH_PATH
-      }
-    )
-
-    test from: :crd_submitted_response_validation
-    test from: :crd_order_dispatch_request
-    test from: :crd_decode_auth_token
-    test from: :crd_retrieve_jwks
-    test from: :crd_token_header
-    test from: :crd_token_payload
-    test from: :crd_hook_request_required_fields
-    test from: :crd_hook_request_optional_fields
-    test from: :crd_hook_request_valid_context do
-      verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@284', 'hl7.fhir.us.davinci-crd_2.0.1@285',
-                            'hl7.fhir.us.davinci-crd_2.0.1@286', 'hl7.fhir.us.davinci-crd_2.0.1@287',
-                            'hl7.fhir.us.davinci-crd_2.0.1@288', 'hl7.fhir.us.davinci-crd_2.0.1@289',
-                            'hl7.fhir.us.davinci-crd_2.0.1@290', 'hl7.fhir.us.davinci-crd_2.0.1@291',
-                            'hl7.fhir.us.davinci-crd_2.0.1@292', 'hl7.fhir.us.davinci-crd_2.0.1@293',
-                            'hl7.fhir.us.davinci-crd_2.0.1@294', 'hl7.fhir.us.davinci-crd_2.0.1@295'
-    end
-    test from: :crd_hook_request_valid_prefetch
-    test from: :crd_card_display_attest_test
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_order_select_group.rb

@@ -1,82 +0,0 @@
-require_relative 'order_select_receive_request_test'
-require_relative 'client_display_cards_attest'
-require_relative 'decode_auth_token_test'
-require_relative 'hook_request_optional_fields_test'
-require_relative 'hook_request_required_fields_test'
-require_relative 'hook_request_valid_context_test'
-require_relative 'hook_request_valid_prefetch_test'
-require_relative 'retrieve_jwks_test'
-require_relative 'submitted_response_validation'
-require_relative 'token_header_test'
-require_relative 'token_payload_test'
-
-module DaVinciCRDTestKit
-  class ClientOrderSelectGroup < Inferno::TestGroup
-    title 'order-select'
-    id :crd_client_order_select
-    description <<~DESCRIPTION
-      The order-select hook fires when a clinician selects one or more orders to place for a patient,
-      (including orders for medications, procedures, labs and other orders). If supported by the CDS Client, this
-      hook may also be invoked each time the clinician selects a detail regarding the order. These tests are based on
-      the following criteria:
-        * [CRD IG requirements for this hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-selecte),
-        which includes the profiles that are expected to be used for the resources resolved to by `context`
-        FHIR ID fields
-        * Specific [order-select `context` requirements](https://cds-hooks.hl7.org/hooks/order-select/2023SepSTU1Ballot/order-select/)
-        defined in the CDS Hooks specification
-
-      This version of the CRD implementation guide refers to version 1.0 of the hook.
-    DESCRIPTION
-
-    run_as_group
-
-    input_order :cds_jwt_iss, :cds_jwk_set
-
-    config(
-      inputs: {
-        auth_token_headers_json: { name: :order_select_auth_token_headers_json },
-        auth_tokens: { name: :order_select_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_select_auth_tokens_jwk_json },
-        client_access_token: { name: :order_select_client_access_token },
-        client_fhir_server: { name: :order_select_client_fhir_server },
-        crd_jwks_keys_json: { name: :order_select_crd_jwks_keys_json },
-        custom_response: { name: :order_select_custom_response },
-        selected_response_types: { name: :order_select_selected_response_types }
-      },
-      outputs: {
-        auth_token_headers_json: { name: :order_select_auth_token_headers_json },
-        auth_token_payloads_json: { name: :order_select_auth_token_payloads_json },
-        auth_tokens: { name: :order_select_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_select_auth_tokens_jwk_json },
-        client_access_token: { name: :order_select_client_access_token },
-        client_fhir_server: { name: :order_select_client_fhir_server },
-        crd_jwks_json: { name: :order_select_crd_jwks_json },
-        crd_jwks_keys_json: { name: :order_select_crd_jwks_keys_json }
-      },
-      options: {
-        hook_name: 'order-select',
-        hook_path: ORDER_SELECT_PATH
-      }
-    )
-
-    test from: :crd_submitted_response_validation
-    test from: :crd_order_select_request
-    test from: :crd_decode_auth_token
-    test from: :crd_retrieve_jwks
-    test from: :crd_token_header
-    test from: :crd_token_payload
-    test from: :crd_hook_request_required_fields
-    test from: :crd_hook_request_optional_fields
-    test from: :crd_hook_request_valid_context do
-      verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@71', 'hl7.fhir.us.davinci-crd_2.0.1@284',
-                            'hl7.fhir.us.davinci-crd_2.0.1@285', 'hl7.fhir.us.davinci-crd_2.0.1@286',
-                            'hl7.fhir.us.davinci-crd_2.0.1@287', 'hl7.fhir.us.davinci-crd_2.0.1@288',
-                            'hl7.fhir.us.davinci-crd_2.0.1@289', 'hl7.fhir.us.davinci-crd_2.0.1@290',
-                            'hl7.fhir.us.davinci-crd_2.0.1@291', 'hl7.fhir.us.davinci-crd_2.0.1@292',
-                            'hl7.fhir.us.davinci-crd_2.0.1@293', 'hl7.fhir.us.davinci-crd_2.0.1@294',
-                            'hl7.fhir.us.davinci-crd_2.0.1@295'
-    end
-    test from: :crd_hook_request_valid_prefetch
-    test from: :crd_card_display_attest_test
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_order_sign_group.rb

@@ -1,81 +0,0 @@
-require_relative 'order_sign_receive_request_test'
-require_relative 'client_display_cards_attest'
-require_relative 'decode_auth_token_test'
-require_relative 'hook_request_optional_fields_test'
-require_relative 'hook_request_required_fields_test'
-require_relative 'hook_request_valid_context_test'
-require_relative 'hook_request_valid_prefetch_test'
-require_relative 'retrieve_jwks_test'
-require_relative 'submitted_response_validation'
-require_relative 'token_header_test'
-require_relative 'token_payload_test'
-
-module DaVinciCRDTestKit
-  class ClientOrderSignGroup < Inferno::TestGroup
-    title 'order-sign'
-    id :crd_client_order_sign
-    description <<~DESCRIPTION
-      The order-sign hook fires when a clinician is ready to sign one or more orders for a patient, (including orders
-      for medications, procedures, labs and other orders). These tests are based on the following criteria:
-        * [CRD IG requirements for this hook](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#order-sign),
-        which includes the profiles that are expected to be used for the resources resolved to by `context`
-        FHIR ID fields
-        * Specific [order-sign `context` requirements](https://cds-hooks.org/hooks/order-sign/)
-        defined in the CDS Hooks specification
-
-      This version of the CRD implementation guide refers to version 1.1 of the hook which, at the time of publication,
-      was not available as a snapshot. Therefore the preceding link refers to the CDS hooks current build.
-    DESCRIPTION
-
-    run_as_group
-
-    input_order :cds_jwt_iss, :cds_jwk_set
-
-    config(
-      inputs: {
-        auth_token_headers_json: { name: :order_sign_auth_token_headers_json },
-        auth_tokens: { name: :order_sign_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_sign_auth_tokens_jwk_json },
-        client_access_token: { name: :order_sign_client_access_token },
-        client_fhir_server: { name: :order_sign_client_fhir_server },
-        crd_jwks_keys_json: { name: :order_sign_crd_jwks_keys_json },
-        custom_response: { name: :order_sign_custom_response },
-        selected_response_types: { name: :order_sign_selected_response_types }
-      },
-      outputs: {
-        auth_token_headers_json: { name: :order_sign_auth_token_headers_json },
-        auth_token_payloads_json: { name: :order_sign_auth_token_payloads_json },
-        auth_tokens: { name: :order_sign_auth_tokens },
-        auth_tokens_jwk_json: { name: :order_sign_auth_tokens_jwk_json },
-        client_access_token: { name: :order_sign_client_access_token },
-        client_fhir_server: { name: :order_sign_client_fhir_server },
-        crd_jwks_json: { name: :order_sign_crd_jwks_json },
-        crd_jwks_keys_json: { name: :order_sign_crd_jwks_keys_json }
-      },
-      options: {
-        hook_name: 'order-sign',
-        hook_path: ORDER_SIGN_PATH
-      }
-    )
-
-    test from: :crd_submitted_response_validation
-    test from: :crd_order_sign_request
-    test from: :crd_decode_auth_token
-    test from: :crd_retrieve_jwks
-    test from: :crd_token_header
-    test from: :crd_token_payload
-    test from: :crd_hook_request_required_fields
-    test from: :crd_hook_request_optional_fields
-    test from: :crd_hook_request_valid_context do
-      verifies_requirements 'hl7.fhir.us.davinci-crd_2.0.1@71', 'hl7.fhir.us.davinci-crd_2.0.1@284',
-                            'hl7.fhir.us.davinci-crd_2.0.1@285', 'hl7.fhir.us.davinci-crd_2.0.1@286',
-                            'hl7.fhir.us.davinci-crd_2.0.1@287', 'hl7.fhir.us.davinci-crd_2.0.1@288',
-                            'hl7.fhir.us.davinci-crd_2.0.1@289', 'hl7.fhir.us.davinci-crd_2.0.1@290',
-                            'hl7.fhir.us.davinci-crd_2.0.1@291', 'hl7.fhir.us.davinci-crd_2.0.1@292',
-                            'hl7.fhir.us.davinci-crd_2.0.1@293', 'hl7.fhir.us.davinci-crd_2.0.1@294',
-                            'hl7.fhir.us.davinci-crd_2.0.1@295'
-    end
-    test from: :crd_hook_request_valid_prefetch
-    test from: :crd_card_display_attest_test
-  end
-end

data/lib/davinci_crd_test_kit/client_tests/client_registration_verification_test.rb

@@ -1,88 +0,0 @@
-require 'jwt'
-
-module DaVinciCRDTestKit
-  class CRDClientRegistrationVerification < Inferno::Test
-    include URLs
-
-    id :crd_client_registration_verification
-    title 'Verify CRD Client Registration'
-    description %(
-        During this test, Inferno will verify that the CRD Client registration details
-        provided are conformant.
-      )
-    input :cds_jwt_iss,
-          title: 'CRD JWT Issuer',
-          description: %(
-            The `iss` claim of the JWT in the Authorization header sent by the CRD client under test on
-            all CRD requests. 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.
-            This input is required for these tests to pass.
-          ),
-          optional: true
-
-    run do
-      assert cds_jwk_set.present?, 'Provide a jwk set in the **CRD JSON Web Key Set (JWKS)** input.'
-
-      jwks_warnings = []
-      parsed_jwk_set = jwk_set(cds_jwk_set, jwks_warnings)
-      jwks_warnings.each { |warning| add_message('warning', warning) }
-
-      assert parsed_jwk_set.length.positive?, 'JWKS content does not include any valid keys.'
-
-      assert messages.none? { |msg| msg[:type] == 'error' }, 'Invalid key set provided. See messages for details'
-    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