davinci_crd_test_kit 0.9.0

data/lib/davinci_crd_test_kit/client_tests/appointment_book_receive_request_test.rb

@@ -0,0 +1,71 @@
+require_relative '../urls'
+
+module DaVinciCRDTestKit
+  class AppointmentBookReceiveRequestTest < Inferno::Test
+    include URLs
+
+    id :crd_appointment_book_request
+    title 'Request received for appointment-book hook'
+    description %(
+        This test waits for an incoming [appointment-book](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#appointment-book)
+        hook request 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.
+      )
+    receives_request :appointment_book
+
+    input :iss
+    input :appointment_book_selected_response_types,
+          title: 'Response types to return from appointment-book 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'],
+          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'
+              }
+            ]
+          }
+
+    run do
+      wait(
+        identifier: "appointment-book #{iss}",
+        message: %(
+          **Appointment Book CDS Service Test**:
+
+          Invoke the appointment-book hook and send a request to:
+
+          `#{appointment_book_url}`
+
+          Inferno will process the request and return CDS cards if successful.
+        )
+      )
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client_tests/client_display_cards_attest.rb

@@ -0,0 +1,48 @@
+require_relative '../urls'
+
+module DaVinciCRDTestKit
+  class ClientCardDisplayAttest < Inferno::Test
+    include URLs
+
+    id :crd_card_display_attest_test
+    title 'Check that Cards returned are displayed to the user'
+
+    input :selected_response_types,
+          type: 'checkbox'
+
+    def format_selected_response_types
+      selected_response_types
+        .map do |response_type|
+        response_type_string =
+          response_type.split('_')
+            .map(&:capitalize)
+            .join(' ')
+            .prepend('- ')
+            .sub('Smart', 'SMART')
+            .sub('Create Update', 'Create/Update')
+            .sub('Companions Prerequisites', 'Companions/Prerequisites')
+        response_type_string
+      end
+        .join("\n")
+    end
+
+    run do
+      identifier = SecureRandom.hex(32)
+      wait(
+        identifier:,
+        message: <<~MESSAGE
+          **Approval Workflow Test**:
+
+          I attest that the following CDS response types were returned and that the client system displays
+          each of the CDS Service Cards to the user:
+
+          #{format_selected_response_types}
+
+          [Click here](#{resume_pass_url}?token=#{identifier}) if the above statement is **true**.
+
+          [Click here](#{resume_fail_url}?token=#{identifier}) if the above statement is **false**.
+        MESSAGE
+      )
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_create_test.rb

@@ -0,0 +1,40 @@
+module DaVinciCRDTestKit
+  class ClientFHIRApiCreateTest < Inferno::Test
+    id :crd_client_fhir_api_create_test
+    title 'Create Interaction'
+    description %(
+        Verify that the CRD client supports the create 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 :create_resources,
+          type: 'textarea',
+          description:
+          'Provide a list of resources to create. e.g., [json_resource_1, json_resource_2]'
+
+    def resource_type
+      config.options[:resource_type]
+    end
+
+    run do
+      assert_valid_json(create_resources)
+      create_resources_list = JSON.parse(create_resources)
+      skip_if(!create_resources_list.is_a?(Array), 'Resources to create not inputted in list format, skipping test.')
+
+      valid_create_resources =
+        create_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_create_resources.blank?,
+              %(No valid #{resource_type} resources were provided to send in Create requests, skipping test.))
+
+      valid_create_resources.each do |create_resource|
+        fhir_create(create_resource)
+        assert_response_status(201)
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_read_test.rb

@@ -0,0 +1,39 @@
+module DaVinciCRDTestKit
+  class ClientFHIRApiReadTest < Inferno::Test
+    id :crd_client_fhir_api_read_test
+    title 'Read Interaction'
+    description %(
+        Verify that the CRD client supports the read 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 :resource_ids
+
+    def resource_type
+      config.options[:resource_type]
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resource ids were provided, skipping test. "
+    end
+
+    def bad_resource_id_message(expected_id)
+      "Expected resource to have id: `#{expected_id}`, but found `#{resource.id}`"
+    end
+
+    run do
+      skip_if resource_ids.blank?, no_resources_skip_message
+
+      resource_id_list = resource_ids.split(',').map(&:strip)
+      assert resource_id_list.present?, "No #{resource_type} id provided."
+
+      resource_id_list.each do |resource_id_to_read|
+        fhir_read resource_type, resource_id_to_read, tags: [resource_type, 'read']
+
+        assert_response_status(200)
+        assert_resource_type(resource_type)
+        assert resource.id.present? && resource.id == resource_id_to_read, bad_resource_id_message(resource_id_to_read)
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client_tests/client_fhir_api_search_test.rb

@@ -0,0 +1,232 @@
+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_paramaters
+      ['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_paramaters.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

@@ -0,0 +1,40 @@
+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
+      )
+
+    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

@@ -0,0 +1,60 @@
+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 resorce 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/decode_auth_token_test.rb

@@ -0,0 +1,40 @@
+module DaVinciCRDTestKit
+  class DecodeAuthTokenTest < Inferno::Test
+    id :crd_decode_auth_token
+    title 'Bearer token can be decoded'
+    description %(
+        Verify that the Bearer token is a properly constructed JWT. As per the [CDS hooks specification](https://cds-hooks.hl7.org/2.0#trusting-cds-clients),
+        each time a CDS Client transmits a request to a CDS Service which requires authentication, the request MUST
+        include an Authorization header presenting the JWT as a "Bearer" token.
+      )
+
+    output :auth_token, :auth_token_payload_json, :auth_token_header_json
+
+    uses_request :hook_request
+
+    run do
+      authorization_header = request.request_header('Authorization')&.value
+      skip_if authorization_header.blank?, 'Request does not include an Authorization header'
+
+      assert(authorization_header.start_with?('Bearer '),
+             'Authorization token must be a JWT presented as a `Bearer` token')
+
+      auth_token = authorization_header.delete_prefix('Bearer ')
+      output(auth_token:)
+
+      begin
+        payload, header =
+          JWT.decode(
+            auth_token,
+            nil,
+            false
+          )
+
+        output auth_token_payload_json: payload.to_json,
+               auth_token_header_json: header.to_json
+      rescue StandardError => e
+        assert false, "Token is not a properly constructed JWT: #{e.message}"
+      end
+    end
+  end
+end

data/lib/davinci_crd_test_kit/client_tests/encounter_discharge_receive_request_test.rb

@@ -0,0 +1,68 @@
+require_relative '../urls'
+
+module DaVinciCRDTestKit
+  class EncounterDischargeReceiveRequestTest < Inferno::Test
+    include URLs
+
+    id :crd_encounter_discharge_request
+    title 'Request received for encounter-discharge hook'
+    description %(
+        This test waits for an incoming [encounter-discharge](https://hl7.org/fhir/us/davinci-crd/STU2/hooks.html#encounter-discharge)
+        hook request and responds to the client with the response types selected as an input.
+      )
+    receives_request :encounter_discharge
+
+    input :iss
+    input :encounter_discharge_selected_response_types,
+          title: 'Response types to return from encounter-discharge hook requests',
+          description: %(
+            Select the cards/action response types that the Inferno hook request endpoints will return. The default
+            response type that will be returned for this hook is the `Instructions` card type.
+          ),
+          type: 'checkbox',
+          default: ['instructions'],
+          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'
+              }
+            ]
+          }
+
+    run do
+      wait(
+        identifier: "encounter-discharge #{iss}",
+        message: %(
+          **Encounter Discharge CDS Service Test**:
+
+          Invoke the encounter-discharge hook and send a request to:
+
+          `#{encounter_discharge_url}`
+
+          Inferno will process the request and return CDS cards if successful.
+        )
+      )
+    end
+  end
+end