davinci_crd_test_kit 0.13.0 → 0.14.0

data/lib/davinci_crd_test_kit/server/endpoints/mock_ehr_endpoints.rb

@@ -0,0 +1,95 @@
+require_relative 'mock_ehr/fhir_read_endpoint'
+require_relative 'mock_ehr/fhir_search_endpoint'
+require_relative 'mock_ehr/fhir_create_endpoint'
+require_relative 'mock_ehr/fhir_update_endpoint'
+require_relative 'mock_ehr/fhir_delete_endpoint'
+require_relative 'mock_ehr/fhir_metadata_endpoint'
+
+module DaVinciCRDTestKit
+  # Include this module within a suite class to add Mock FHIR Server
+  # endpoints with data supplied by an input containing a Bundle
+  # that can be accessed and updated by calls to the suite's endpoints.
+  # Defaults to driving the CapabilityStatement and supported search
+  # parameters off of US Core 6.1.0, but a different set of metadata
+  # can be provided at inclusion time by using `with` and specifying
+  # either a `metadata_dir:` or providing a block that resolves to
+  # a list of metadata files to use.
+  #
+  # @example Default US Core 6.1.0 metadata
+  #   class MyTestSuite < Inferno::TestSuite
+  #     include MockEHREndpoints
+  #   end
+  #
+  # @example Custom metadata directory (e.g. US Core 7.0.0)
+  #   US_CORE_7_DIR = File.join(
+  #     Gem::Specification.find_by_name('us_core_test_kit').gem_dir,
+  #     'lib', 'us_core_test_kit', 'generated', 'v7.0.0'
+  #   )
+  #
+  #   class MyTestSuite < Inferno::TestSuite
+  #     include MockEHREndpoints.with(metadata_dir: US_CORE_7_DIR)
+  #   end
+  #
+  # @example Custom file list via block
+  #   class MyTestSuite < Inferno::TestSuite
+  #     include(MockEHREndpoints.with { Dir.glob('/path/to/my/metadata/**/metadata.yml') })
+  #   end
+  module MockEHREndpoints
+    def self.included(base)
+      configure(base)
+    end
+
+    def self.with(metadata_dir: nil, &block)
+      Module.new do
+        define_singleton_method(:included) do |base|
+          MockEHREndpoints.send(:configure, base, metadata_dir:, metadata_files_proc: block)
+        end
+      end
+    end
+
+    def self.configure(base, metadata_dir: nil, metadata_files_proc: nil)
+      base.route :get, FHIR_METADATA_ROUTE, build_metadata_endpoint(metadata_dir:, metadata_files_proc:)
+      search_endpoint =
+        if metadata_dir || metadata_files_proc
+          build_search_endpoint(metadata_dir:, metadata_files_proc:)
+        else
+          MockEHR::FHIRSearchEndpoint
+        end
+      base.suite_endpoint :post, FHIR_SEARCH_POST_ROUTE, search_endpoint
+      base.suite_endpoint :get, FHIR_RESOURCE_TYPE_ROUTE, search_endpoint
+      base.suite_endpoint :get, FHIR_INSTANCE_ROUTE, MockEHR::FHIRReadEndpoint
+      base.suite_endpoint :post, FHIR_RESOURCE_TYPE_ROUTE, MockEHR::FHIRCreateEndpoint
+      base.suite_endpoint :put, FHIR_INSTANCE_ROUTE, MockEHR::FHIRUpdateEndpoint
+      base.suite_endpoint :delete, FHIR_INSTANCE_ROUTE, MockEHR::FHIRDeleteEndpoint
+    end
+    private_class_method :configure
+
+    def self.build_metadata_endpoint(metadata_dir: nil, metadata_files_proc: nil)
+      return MockEHR::FHIRMetadataEndpoint unless metadata_dir || metadata_files_proc
+
+      if metadata_files_proc
+        Class.new(MockEHR::FHIRMetadataEndpoint) do
+          define_singleton_method(:metadata_files) { metadata_files_proc.call }
+        end
+      else
+        Class.new(MockEHR::FHIRMetadataEndpoint) do
+          define_singleton_method(:metadata_dir) { metadata_dir }
+        end
+      end
+    end
+    private_class_method :build_metadata_endpoint
+
+    def self.build_search_endpoint(metadata_dir: nil, metadata_files_proc: nil)
+      if metadata_files_proc
+        Class.new(MockEHR::FHIRSearchEndpoint) do
+          define_singleton_method(:metadata_files) { metadata_files_proc.call }
+        end
+      else
+        Class.new(MockEHR::FHIRSearchEndpoint) do
+          define_method(:metadata_directory) { metadata_dir }
+        end
+      end
+    end
+    private_class_method :build_search_endpoint
+  end
+end

data/lib/davinci_crd_test_kit/server/jobs/invoke_hook.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative '../../cross_suite/tags'
+require_relative '../../cross_suite/base_urls'
+require_relative '../../cross_suite/cards_identification'
+require_relative '../endpoints/mock_ehr/fhir_request_handler'
+require_relative '../server_base_urls'
+
+module DaVinciCRDTestKit
+  module Jobs
+    class InvokeHook
+      include Sidekiq::Job
+      include DaVinciCRDTestKit::CardsIdentification
+      include DaVinciCRDTestKit::ServerBaseURLs
+
+      sidekiq_options retry: false
+
+      def perform(test_session_id, request_bodies, service_endpoint, inferno_base_url, jwks_kid,
+                  encryption_method, request_tag, continuation_url, failure_url, acknowledge_before_continuing,
+                  coverage_info_configuration_supported)
+        @test_session_id = test_session_id
+        @service_endpoint = service_endpoint
+        @inferno_base_url = inferno_base_url
+        @jwks_kid = jwks_kid
+        @encryption_method = encryption_method
+        @request_tag = request_tag
+        @continuation_url = continuation_url
+        @failure_url = failure_url
+        @acknowledge_before_continuing = acknowledge_before_continuing
+        @coverage_info_configuration_supported = coverage_info_configuration_supported
+
+        perform_hook_invocations(request_bodies)
+      end
+
+      def perform_hook_invocations(request_bodies)
+        await_test_waiting # let Inferno start waiting so it can respond to FHIR requests
+
+        request_bodies.each do |request|
+          break unless test_waiting?
+
+          request_body = prepare_hook_request(request)
+          response = send_hook_invocation(request_body.to_json)
+          send_coverage_info_configuration_invocation(request_body, response)
+          send_unknown_configuration_invocation(request_body, response)
+          send_unknown_context_invocation(request_body, response)
+          send_unknown_cds_hooks_element_invocation(request_body, response)
+        end
+
+        return unless test_waiting?
+
+        # end the wait to continue the tests
+        Faraday.get(@continuation_url) unless @acknowledge_before_continuing
+      rescue StandardError => e
+        Faraday.get(@failure_url, { message: "Hook invocation failed: #{e.message}" })
+      end
+
+      def test_run_id
+        @test_run_id ||= test_runs_repo.last_test_run(@test_session_id).id
+      end
+
+      def test_runs_repo
+        @test_runs_repo ||= Inferno::Repositories::TestRuns.new
+      end
+
+      def requests_repo
+        @requests_repo ||= Inferno::Repositories::Requests.new
+      end
+
+      def results_repo
+        @results_repo ||= Inferno::Repositories::Results.new
+      end
+
+      def service_connection
+        @service_connection ||= Faraday.new(url: @service_endpoint, request: { open_timeout: 30 })
+      end
+
+      def test_done?
+        test_runs_repo.status_for_test_run(test_run_id) == 'done'
+      end
+
+      def await_test_waiting
+        sleep 0.5 until test_waiting? || test_done?
+
+        @result_id = results_repo.find_waiting_result(test_run_id:)&.id
+      end
+
+      def test_waiting?
+        results_repo.find_waiting_result(test_run_id:).present?
+      end
+
+      def prepare_hook_request(parsed_request)
+        parsed_request['hookInstance'] = SecureRandom.uuid
+        parsed_request['fhirServer'] = fhir_url
+        update_simulated_server_token(parsed_request)
+        parsed_request
+      end
+
+      def update_simulated_server_token(parsed_request)
+        parsed_request['fhirAuthorization'] = {} if parsed_request['fhirAuthorization'].nil?
+        fhir_authorization = parsed_request['fhirAuthorization']
+
+        fhir_authorization['expires_in'] = 300 unless fhir_authorization['expires_in'].present?
+        fhir_authorization['access_token'] =
+          MockEHR::FHIRRequestHandler.session_id_to_token(@test_session_id, fhir_authorization['expires_in'].to_i / 60)
+      end
+
+      def send_hook_invocation(request_body, extra_tags = [])
+        token = JwtHelper.build(
+          aud: @service_endpoint,
+          iss: @inferno_base_url,
+          jku: "#{@inferno_base_url}/jwks.json",
+          kid: @jwks_kid,
+          encryption_method: @encryption_method
+        )
+        headers = { 'Content-type' => 'application/json', 'Authorization' => "Bearer #{token}" }
+        response = invoke_hook(request_body, headers)
+        persist_hook_request(response, [@request_tag] + extra_tags, headers)
+        response
+      end
+
+      def send_coverage_info_configuration_invocation(request_body, response)
+        return unless @coverage_info_configuration_supported
+        return if @coverage_info_configuration_invoked
+        return unless response.status == 200
+        return unless coverage_info_response?(parsed_response_body(response))
+        return unless test_waiting?
+
+        configured_request_body = JSON.parse(request_body.to_json)
+        prepare_hook_request(configured_request_body)
+        disable_coverage_info_configuration!(configured_request_body)
+        send_hook_invocation(configured_request_body.to_json, [COVERAGE_INFO_DISABLED_TAG])
+        @coverage_info_configuration_invoked = true
+      end
+
+      def send_unknown_configuration_invocation(request_body, response)
+        return if @unknown_configuration_invoked
+        return unless response.status == 200
+        return unless coverage_info_response?(parsed_response_body(response))
+        return unless test_waiting?
+
+        request_body = JSON.parse(request_body.to_json)
+        prepare_hook_request(request_body)
+        add_unknown_configuration(request_body)
+        send_hook_invocation(request_body.to_json, [UNKNOWN_CONFIGURATION_TAG])
+
+        @unknown_configuration_invoked = true
+      end
+
+      def send_unknown_context_invocation(request_body, response)
+        return if @unknown_context_invoked
+        return unless response.status == 200
+        return unless coverage_info_response?(parsed_response_body(response))
+        return unless test_waiting?
+
+        request_body = JSON.parse(request_body.to_json)
+        prepare_hook_request(request_body)
+        add_unknown_context(request_body)
+        send_hook_invocation(request_body.to_json, [UNKNOWN_CONTEXT_TAG])
+
+        @unknown_context_invoked = true
+      end
+
+      def send_unknown_cds_hooks_element_invocation(request_body, response)
+        return if @unknown_cds_hooks_element_invoked
+        return unless response.status == 200
+        return unless coverage_info_response?(parsed_response_body(response))
+        return unless test_waiting?
+
+        request_body = JSON.parse(request_body.to_json)
+        prepare_hook_request(request_body)
+        add_unknown_element(request_body)
+        send_hook_invocation(request_body.to_json, [UNKNOWN_ELEMENT_TAG])
+
+        @unknown_cds_hooks_element_invoked = true
+      end
+
+      def random_key
+        ('a'..'z').to_a.sample(16).join
+      end
+
+      def add_unknown_configuration(request_body)
+        request_body['extension'] ||= {}
+        request_body['extension']['davinci-crd.configuration'] ||= {}
+        request_body['extension']['davinci-crd.configuration'][random_key] = true
+      end
+
+      def add_unknown_context(request_body)
+        request_body['context'] ||= {}
+        request_body['context'][random_key] ||= random_key
+      end
+
+      def add_unknown_element(request_body)
+        request_body[random_key] ||= random_key
+      end
+
+      def parsed_response_body(response)
+        JSON.parse(response.env.response_body.to_s)
+      rescue JSON::ParserError, TypeError
+        nil
+      end
+
+      def invoke_hook(request_body, headers)
+        service_connection.post('', request_body, headers)
+      end
+
+      def persist_hook_request(response, tags, headers)
+        inferno_request_headers = headers.map { |name, value| { name:, value: } }
+        inferno_response_headers = response.headers&.map { |name, value| { name:, value: } }
+        requests_repo.create(
+          verb: 'POST',
+          url: response.env.url.to_s,
+          direction: 'outgoing',
+          status: response.status,
+          request_body: response.env.request_body,
+          response_body: response.env.response_body,
+          test_session_id: @test_session_id,
+          result_id: @result_id,
+          request_headers: inferno_request_headers,
+          response_headers: inferno_response_headers,
+          tags:
+        )
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/{jwt_helper.rb → server/jwt_helper.rb}

@@ -1,4 +1,4 @@
-require_relative 'jwks'
+require_relative 'endpoints/jwks'
 
 module DaVinciCRDTestKit
   class JwtHelper
@@ -6,17 +6,6 @@ module DaVinciCRDTestKit
       new(...).signed_jwt
     end
 
-    def self.decode_jwt(token, jwks_hash, kid = nil)
-      jwks = JWT::JWK::Set.new(jwks_hash)
-      jwks.filter! { |key| key[:use] == 'sig' }
-      algorithms = jwks.map { |key| key[:alg] }.compact.uniq
-      begin
-        JWT.decode(token, kid, true, algorithms:, jwks:)
-      rescue StandardError => e
-        raise Inferno::Exceptions::AssertionException, e.message
-      end
-    end
-
     attr_reader :aud, :encryption_method, :exp, :iat, :iss, :jku, :jti, :kid
 
     def initialize(

data/lib/davinci_crd_test_kit/server/resource_extractor.rb

@@ -0,0 +1,68 @@
+module DaVinciCRDTestKit
+  module ResourceExtractor
+    def resources_from_request(request)
+      request_body = JSON.parse(request.request_body)
+      return [] unless request_body.is_a?(Hash)
+
+      context_resources(request_body) + prefetch_resources(request_body)
+    rescue JSON::ParserError
+      []
+    end
+
+    def context_resources(request_body)
+      context = request_body['context']
+      return [] unless context.is_a?(Hash)
+
+      bundle_entry_resources(parse_fhir_data(context['appointments'])) +
+        bundle_entry_resources(parse_fhir_data(context['draftOrders'])) +
+        resources_from_value(context['fulfillmentTasks'])
+    end
+
+    def prefetch_resources(request_body)
+      prefetch = request_body['prefetch']
+      return [] unless prefetch.is_a?(Hash)
+
+      prefetch.values.flat_map { |value| resources_from_value(value) }
+    end
+
+    def resources_from_value(value)
+      case value
+      when Array
+        value.flat_map { |entry| resources_from_value(entry) }
+      when Hash
+        resources_from_hash(value)
+      else
+        []
+      end
+    end
+
+    def resources_from_hash(contents)
+      return [] unless contents['resourceType'].present?
+
+      fhir_data = parse_fhir_data(contents)
+      return [] unless fhir_data.present?
+
+      return bundle_entry_resources(fhir_data) if fhir_data.is_a?(FHIR::Bundle)
+
+      [fhir_data]
+    end
+
+    def bundle_entry_resources(bundle)
+      return [] unless bundle.is_a?(FHIR::Bundle)
+
+      bundle.entry.filter_map do |entry|
+        next unless entry&.resource.present?
+
+        entry.resource
+      end
+    end
+
+    def parse_fhir_data(contents)
+      return unless contents.present?
+
+      FHIR.from_contents(contents.to_json)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/server_abstract_invoke_hook_test.rb

@@ -0,0 +1,165 @@
+require_relative 'server_hook_helper'
+require_relative '../cross_suite/tags'
+require_relative 'jobs/invoke_hook'
+
+module DaVinciCRDTestKit
+  class ServerAbstractInvokeHookTest < Inferno::Test
+    include ServerHookHelper
+
+    # must include the corresponding server_urls class when using in a suite
+
+    title 'Invoke Hook'
+    id :crd_server_invoke_hook_test
+    description %(
+        This test initiates POST request(s) to a specified CDS Service using the JSON body list provided by the user.
+        As indicated in the [CDS Hooks specification section on Calling a CDS Service](https://cds-hooks.hl7.org/2.0/#calling-a-cds-service),
+        the service endpoint is constructed by appending the individual service id to the CDS Service base URL,
+        following the format `{baseUrl}/cds-services/{service.id}`. While the requests are being made,
+        Inferno will enable FHIR endpoints that serve the data indicated in the Mock EHR Bundle so that the
+        tested server can access additional information not provided in the hook request.
+
+        If running this group only, the user will need to provide the `service.id` to call the specified service.
+        Otherwise, the `service.id` is derived from the CDS Services that are retrieved through a query to the
+        discovery endpoint.
+
+        The test will be skipped if the CRD server does not host a CDS Service corresponding to the hook that
+        is being tested.
+
+        The test is deemed successful if the CRD server returns a 200 HTTP response for all requests.
+      )
+    input_order :base_url, :encryption_method, :jwks_kid
+    input :base_url
+    input :service_ids,
+          description: %(
+              If blank, Inferno will attempt to infer the service id to use by finding a service entry in the
+              Discovery response for the target hook. If it cannot be inferred, the tests will be skipped.
+            ),
+          optional: true
+    input :service_request_bodies,
+          optional: true,
+          type: 'textarea',
+          description: 'To send multiple requests, provide as a JSON list, e.g., [json_body_1, json_body_2].'
+    input :encryption_method,
+          title: 'JWT Signing Algorithm',
+          description: <<~DESCRIPTION,
+            CDS Hooks recommends ES384 and RS384 for JWT signature verification.
+            Select which method to use.
+          DESCRIPTION
+          type: 'radio',
+          options: {
+            list_options: [
+              {
+                label: 'ES384',
+                value: 'ES384'
+              },
+              {
+                label: 'RS384',
+                value: 'RS384'
+              }
+            ]
+          }
+    input :jwks_kid,
+          title: 'CDS Services JWKS kid',
+          description: <<~DESCRIPTION,
+            The key ID of the JWKS private key to use for signing the JWTs when invoking a CDS service endpoint
+            requiring authentication.
+            Defaults to the first JWK in the list if no kid is supplied.
+          DESCRIPTION
+          optional: true
+    input :mock_ehr_bundle,
+          title: 'Mock EHR Data',
+          description: <<~DESCRIPTION,
+            A FHIR Bundle containing resources that Inferno will make available via the FHIR API hosted
+            by its simulated CRD client that will initiate the CDS Hooks requests.
+          DESCRIPTION
+          type: 'textarea',
+          optional: true,
+          default: '{"resourceType":"Bundle","type":"collection"}'
+    input :manual_continuation,
+          title: 'Require acknowledgement of completed hook requests?',
+          description: %(
+              By default, Inferno will continue evaluation of the hook response(s) immediately after completing
+              the request(s). To keep Inferno's simulated CRD Client and its FHIR endpoints active longer,
+              select the "Continue on user acknowledgement" option and you will be asked to click a link when
+              you are ready for Inferno to continue.
+            ),
+          type: 'radio',
+          default: 'no',
+          options: {
+            list_options: [
+              {
+                label: 'Continue when hook invocation(s) complete',
+                value: 'no'
+              }, {
+                label: 'Continue on user acknowledgement',
+                value: 'yes'
+              }
+            ]
+          },
+          optional: true
+
+    output :invoked_hook
+    output :continuation_url
+
+    run do
+      discovery_url = "#{base_url.chomp('/')}/cds-services"
+
+      begin
+        bundle_resource = FHIR.from_contents(mock_ehr_bundle)
+      rescue StandardError
+        bundle_resource = nil
+      end
+      skip_if !bundle_resource.is_a?(FHIR::Bundle),
+              'mock_ehr_bundle input must be a FHIR Bundle resource; skipping test.'
+
+      skip_if service_request_bodies.blank?,
+              'Request body not provided, skipping test.'
+      assert_valid_json(service_request_bodies)
+
+      payloads = [JSON.parse(service_request_bodies)].flatten
+      skip_if tested_hook_name == ANY_HOOK_TAG && payloads.length != 1,
+              'The *Demonstrate a Hook Invocation* test supports only one request body.'
+      invoked_hook = identify_hook(payloads)
+      output(invoked_hook:)
+      service_id = target_service_id(service_ids, invoked_hook)
+      skip_if service_id.blank?, "No service id provided or discovered for the #{invoked_hook} hook"
+
+      service_endpoint = "#{discovery_url}/#{service_id}"
+      continuation_url = "#{resume_pass_url}?token=#{test_session_id}"
+      output(continuation_url:)
+      failure_url = "#{resume_fail_url}?token=#{test_session_id}"
+
+      acknowledge_before_continuing = manual_continuation == 'yes'
+      Inferno::Jobs.perform(DaVinciCRDTestKit::Jobs::InvokeHook, test_session_id,
+                            payloads, service_endpoint, inferno_base_url, jwks_kid, encryption_method,
+                            tested_hook_name, continuation_url, failure_url, acknowledge_before_continuing,
+                            coverage_info_configuration_supported?)
+
+      wait(
+        identifier: test_session_id,
+        timeout: acknowledge_before_continuing ? 900 : 300,
+        message: wait_message(acknowledge_before_continuing, continuation_url)
+      )
+    end
+
+    def wait_message(acknowledge_before_continuing, continuation_url)
+      message = "Inferno's simulated CRD Client will initiate hook requests to the server. " \
+                'During these invocations the server will be able to make FHIR requests ' \
+                "against Inferno's simulated CRD Client."
+
+      return message unless acknowledge_before_continuing
+
+      "#{message}\n\n#{continuation_message(continuation_url)}"
+    end
+
+    def continuation_message(continuation_url)
+      'Once all hook requests have been made and the server has gathered all desired information ' \
+        "from the FHIR server of Inferno's simulated CRD Client, [click here](#{continuation_url}) " \
+        'to continue the tests.'
+    end
+
+    def coverage_info_configuration_supported?
+      false
+    end
+  end
+end

data/lib/davinci_crd_test_kit/server/server_base_urls.rb

@@ -0,0 +1,30 @@
+require_relative '../cross_suite/base_urls'
+
+module DaVinciCRDTestKit
+  FHIR_ROUTE = '/fhir'.freeze
+  FHIR_METADATA_ROUTE = "#{FHIR_ROUTE}/metadata".freeze
+  FHIR_INSTANCE_ROUTE = "#{FHIR_ROUTE}/:resource_type/:resource_id".freeze
+  FHIR_RESOURCE_TYPE_ROUTE = "#{FHIR_ROUTE}/:resource_type".freeze
+  FHIR_SEARCH_POST_ROUTE = "#{FHIR_ROUTE}/:resource_type/_search".freeze
+
+  module ServerBaseURLs
+    include BaseURLs
+
+    def fhir_url
+      inferno_base_url + FHIR_ROUTE
+    end
+
+    # alias for OIDC from SMART client tests
+    def client_fhir_base_url
+      fhir_url
+    end
+
+    def instance_url
+      inferno_base_url + INSTANCE_ROUTE
+    end
+
+    def search_url
+      inferno_base_url + RESOURCE_TYPE_ROUTE
+    end
+  end
+end

data/lib/davinci_crd_test_kit/{server_hook_helper.rb → server/server_hook_helper.rb}

@@ -1,4 +1,4 @@
-require_relative 'tags'
+require_relative '../cross_suite/tags'
 
 module DaVinciCRDTestKit
   module ServerHookHelper

data/lib/davinci_crd_test_kit/{server_hook_request_validation.rb → server/server_hook_request_validation.rb}

@@ -1,4 +1,4 @@
-require_relative 'hook_request_field_validation'
+require_relative '../cross_suite/hook_request_field_validation'
 
 module DaVinciCRDTestKit
   module ServerHookRequestValidation

data/lib/davinci_crd_test_kit/{test_helper.rb → server/server_test_helper.rb}

@@ -1,13 +1,17 @@
+require_relative '../cross_suite/tags'
+
 module DaVinciCRDTestKit
-  module TestHelper
+  module ServerTestHelper
     def parse_json(input)
       assert_valid_json(input)
       JSON.parse(input)
     end
 
-    def verify_at_least_one_test_passes(test_groups, id_pattern, error_message, id_exclude_pattern = nil)
+    def verify_at_least_one_test_passes(test_groups, id_pattern, error_message, id_exclude_pattern = nil) # rubocop:disable Metrics/CyclomaticComplexity
       runnables = test_groups.map do |group|
-        group.tests.find do |test|
+        next if ALL_HOOK_TAGS.none? { |hook_name| group.title.include?(hook_name) }
+
+        group.groups[2].tests.find do |test| # response verification subgroup
           test.id.include?(id_pattern) && (!id_exclude_pattern || !test.id.include?(id_exclude_pattern))
         end
       end.compact

data/lib/davinci_crd_test_kit/server/v2.0.1/crd_metadata/Appointment.yml

@@ -0,0 +1,5 @@
+---
+:resource: Appointment
+:profile_url: http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-appointment
+:profile_name: CRD Appointment
+:profile_version: 2.0.1

data/lib/davinci_crd_test_kit/server/v2.0.1/crd_metadata/ClaimResponse.yml

@@ -0,0 +1,5 @@
+---
+:resource: ClaimResponse
+:profile_url: http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-claimresponse
+:profile_name: HRex Prior authorization 
+:profile_version: 2.0.1

data/lib/davinci_crd_test_kit/server/v2.0.1/crd_metadata/CommunicationRequest.yml

@@ -0,0 +1,5 @@
+---
+:resource: CommunicationRequest
+:profile_url: http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-communicationrequest
+:profile_name: CRD CommunicationRequest
+:profile_version: 2.0.1

data/lib/davinci_crd_test_kit/server/v2.0.1/crd_metadata/Coverage.yml

@@ -0,0 +1,21 @@
+---
+:resource: Coverage
+:profile_url: http://hl7.org/fhir/us/davinci-crd/StructureDefinition/profile-coverage
+:profile_name: CRD Coverage
+:profile_version: 2.0.1
+:search_definitions:
+  :patient:
+    :paths:
+    - beneficiary
+    :full_paths:
+    - Coverage.beneficiary
+    :type: Reference
+  :status:
+    :paths:
+    - status
+    :full_paths:
+    - Coverage.status
+    :type: code
+:include_params: []
+:revincludes:
+- Provenance:target