bulk_data_test_kit 0.9.0

data/lib/bulk_data_test_kit/export_operation_tests.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative 'export_kick_off_performer'
+require_relative 'bulk_data_test_kit_properties'
+
+module BulkDataTestKit
+  module BulkDataExportOperationTests
+    extend Forwardable
+
+    def_delegators 'self.class', :properties
+    def_delegators 'properties',
+                   :resource_type,
+                   :bulk_export_url
+
+    def check_export_support
+      fhir_get_capability_statement(client: :bulk_server)
+      assert_response_status([200, 201])
+
+      assert_valid_json(request.response_body)
+      capability_statement = FHIR.from_contents(request.response_body)
+
+      warning do
+        has_instantiates = capability_statement&.instantiates&.any? do |canonical|
+          canonical.match(%r{^http://hl7.org/fhir/uv/bulkdata/CapabilityStatement/bulk-data(\|\S+)?$})
+        end
+        assert has_instantiates,
+               'Server did not declare conformance to the Bulk Data IG by including ' \
+               "'http://hl7.org/fhir/uv/bulkdata/CapabilityStatement/bulk-data' in " \
+               "CapabilityStatement.instantiates element (#{capability_statement&.instantiates})"
+      end
+
+      group_resource_capabilities = nil
+
+      capability_statement&.rest&.each do |rest|
+        group_resource_capabilities = if resource_type == 'system'
+                                        rest
+                                      else
+                                        rest.resource&.find do |resource|
+                                          resource.type == resource_type
+                                        end
+                                      end
+      end
+
+      assert group_resource_capabilities.respond_to?(:operation) && group_resource_capabilities.operation&.any?,
+             "Server CapabilityStatement did not declare support for any operations on the #{resource_type} resource"
+
+      has_export_operation = group_resource_capabilities.operation&.any? do |operation|
+        name_match = (operation.name == 'export')
+        operationDefURL = resource_type == 'system' ? 'export' : "#{resource_type.downcase}-export"
+
+        if name_match && !operation.definition&.match(%r{^http://hl7.org/fhir/uv/bulkdata/OperationDefinition/#{operationDefURL}(\|\S+)?$})
+          info("Server CapabilityStatement does not include export operation with definition http://hl7.org/fhir/uv/bulkdata/OperationDefinition/#{operationDefURL}")
+        end
+        name_match
+      end
+      warning do
+        assert has_export_operation,
+               "Server CapabilityStatement did not declare support for an operation named export in the #{resource_type} " \
+               'resource (operation.name should be export)'
+      end
+    end
+
+    def rejects_without_authorization
+      skip_if bearer_token.blank?, 'Bearer token is not set and thus not required to connect to server.'
+
+      url = bulk_export_url.dup
+      url = bulk_export_url.gsub('[group_id]', group_id) if resource_type == 'Group'
+
+      perform_export_kick_off_request(use_token: false, url:)
+      assert_response_status([400, 401])
+    end
+
+    def export_kick_off_success
+      use_token = !bearer_token.blank?
+
+      url = bulk_export_url.dup
+      url = bulk_export_url.gsub('[group_id]', group_id) if resource_type == 'Group'
+
+      perform_export_kick_off_request(use_token:, url:)
+      assert_response_status(202)
+
+      polling_url = request.response_header('content-location')&.value
+      assert polling_url.present?, 'Export response headers did not include "Content-Location"'
+
+      polling_url
+    end
+
+    def export_status_check_success(status_polling_url)
+      skip 'Server response did not have Content-Location in header' unless status_polling_url.present?
+
+      timeout = bulk_timeout.to_i
+
+      if !timeout.positive?
+        timeout = 180
+      elsif timeout > 600
+        timeout = 600
+      end
+
+      wait_time = 1
+      start = Time.now
+      used_time = 0
+
+      loop do
+        get(status_polling_url, headers: { authorization: "Bearer #{bearer_token}", accept: 'application/json' })
+
+        retry_after_val = request.response_header('retry-after')&.value.to_i
+
+        wait_time = retry_after_val.positive? ? retry_after_val : wait_time *= 2
+
+        used_time = Time.now - start
+
+        total_time_to_next_poll = Time.now - start + wait_time
+
+        break if response[:status] != 202 || total_time_to_next_poll > timeout
+
+        sleep wait_time
+      end
+
+      if response[:status] == 202
+        skip "Server already used #{used_time} seconds processing this request, " \
+            "and next poll is #{wait_time} seconds after. " \
+            "The total wait time for next poll is more than #{timeout} seconds time out setting."
+      end
+
+      assert_response_status(200)
+
+      assert request.response_header('content-type')&.value&.include?('application/json'),
+             'Content-Type not application/json'
+
+      assert_valid_json(response[:body])
+      response_body = JSON.parse(response[:body])
+
+      %w[transactionTime request requiresAccessToken output error].each do |key|
+        assert response_body.key?(key), "Complete Status response did not contain \"#{key}\" as required"
+      end
+
+      requires_access_token = response_body['requiresAccessToken'].to_s.downcase
+      status_response = response[:body]
+
+      [requires_access_token, status_response]
+    end
+
+    def check_bulk_data_output(export_status_response)
+      assert export_status_response.present?, 'Bulk Data Server status response not found'
+
+      assert_valid_json(export_status_response)
+      status_output = JSON.parse(export_status_response)['output']
+      assert status_output, 'Bulk Data Server status response does not contain output'
+
+      skip_if status_output.empty?, 'Bulk Data Server status response does not contain any data in the output'
+
+      begin
+        status_output_json = status_output.to_json
+        bulk_download_url = status_output[0]['url']
+
+        [status_output_json, bulk_download_url]
+      ensure
+        status_output.each do |file|
+          %w[type url].each do |key|
+            assert file.key?(key), "Output file did not contain \"#{key}\" as required"
+          end
+
+          if config.options[:require_absolute_urls_in_output]
+            assert file['url'].to_s.match?(%r{\Ahttps?://}),
+                   "URLs in output file must be absolute, but found `#{file['url']}`."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/export_parameters_tests.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'export_kick_off_performer'
+require_relative 'bulk_data_test_kit_properties'
+
+module BulkDataTestKit
+  module BulkDataExportParametersTests
+    extend Forwardable
+
+    def_delegators 'self.class', :properties
+    def_delegators 'properties',
+                   :resource_type,
+                   :bulk_export_url
+
+    def perform_outputFormat_param_test
+      url = bulk_export_url.dup
+      url = bulk_export_url.gsub('[group_id]', group_id) if resource_type == 'Group'
+
+      ['application/fhir+ndjson', 'application/ndjson', 'ndjson'].each do |format|
+        kickoff_url = url.dup
+        perform_export_kick_off_request(params: { _outputFormat: format }, url: kickoff_url)
+        assert_response_status(202)
+
+        delete_export_kick_off_request
+      end
+    end
+
+    def perform_since_param_test(since_timestamp_param)
+      fhir_instant_regex = /
+        ([0-9]([0-9]([0-9][1-9]|[1-9]0)|[1-9]00)|[1-9]000)
+        -(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])
+        T([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)
+        ?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))
+      /x
+
+      url = bulk_export_url.dup
+      url = bulk_export_url.gsub('[group_id]', group_id) if resource_type == 'Group'
+
+      assert since_timestamp_param.match?(fhir_instant_regex),
+             "The provided `_since` timestamp `#{since_timestamp_param}` is not a valid " \
+             '[FHIR instant](https://www.hl7.org/fhir/datatypes.html#instant).'
+
+      perform_export_kick_off_request(params: { _since: since_timestamp_param }, url:)
+      assert_response_status(202)
+
+      delete_export_kick_off_request
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_export_cancel_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../export_cancel_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataExportCancelTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportCancelTests
+      include BulkDataTestKit::ExportKickOffPerformer
+
+      id :bulk_data_export_cancel
+
+      title 'Bulk Data Server returns "202 Accepted" for delete request'
+      description <<~DESCRIPTION
+        After a bulk data request has been started, a client MAY send a delete request to the URL provided in the Content-Location header to cancel the request.
+        Bulk Data Server MUST support client's delete request and return HTTP Status Code of "202 Accepted"
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#bulk-data-delete-request'
+
+      output :cancelled_polling_url
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type],
+          bulk_export_url: config.options[:bulk_export_url]
+        )
+      end
+
+      run do
+        cancelled_polling_url = perform_export_cancel_test
+        output cancelled_polling_url:
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_export_kick_off_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../export_operation_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataKickOffTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportOperationTests
+      include BulkDataTestKit::ExportKickOffPerformer
+
+      id :bulk_data_kick_off
+
+      title 'Bulk Data Server returns "202 Accepted" and "Content-location" for bulk data $export operations'
+      description <<~DESCRIPTION
+        Response - Success
+
+        * HTTP Status Code of 202 Accepted
+        * Content-Location header with the absolute URL of an endpoint for subsequent status requests (polling location)
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#response---success'
+
+      output :polling_url
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type],
+          bulk_export_url: config.options[:bulk_export_url]
+        )
+      end
+
+      run do
+        polling_url = export_kick_off_success
+        output polling_url:
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_export_operation_support_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../export_operation_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataExportOperationSupportTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportOperationTests
+
+      id :bulk_data_export_operation_support
+      title 'Bulk Data Server declares support for particular bulk data export operation in CapabilityStatement'
+      description <<~DESCRIPTION
+        This test verifies that the Bulk Data Server declares support for
+        a particular bulk data operation in its server CapabilityStatement.
+
+        Given flexibility in the FHIR specification for declaring constrained
+        OperationDefinitions, this test only verifies that the server declares
+        any operation for the specific resource in the CapabilityStatement.  It does not verify that it
+        declares the standard bulk data export OperationDefinition provided in the
+        Bulk Data specification, nor does it attempt to resolve any non-standard
+        OperationDefinitions to verify if it is a constrained version of the
+        standard OperationDefintion.
+
+        This test will provide a warning if no operations are declared via the
+        `CapabilityStatement.rest.resource.operation.name` element.  It will
+        also provide an informational message if an operation on the particular
+        resource exists, but does not point to the standard OperationDefinition
+        canonical URL.
+
+        Additionally, this test provides a warning if the bulk data server does
+        not include the following URL in its `CapabilityStatement.instantiates`
+        element: http://hl7.org/fhir/uv/bulkdata/CapabilityStatement/bulk-data
+      DESCRIPTION
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type]
+        )
+      end
+
+      run do
+        check_export_support
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_export_tests_test_group.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'bulk_data_group_export_test_group'
+require_relative 'bulk_data_patient_export_test_group'
+require_relative 'bulk_data_system_export_test_group'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataSmartBackendServicesGroupV101 < Inferno::TestGroup
+      id :bulk_data_export_tests_v101
+      title 'Bulk Data Export Tests'
+
+      group do
+        id :bulk_data_server_tests
+        title 'Bulk Data Server TLS Tests'
+        run_as_group
+
+        test from: :tls_version_test do
+          title 'Bulk Data Server is secured by transport layer security'
+          description <<~DESCRIPTION
+            [§170.315(g)(10) Test
+            Procedure](https://www.healthit.gov/test-method/standardized-api-patient-and-population-services)
+            requires that all exchanges described herein between a client and a
+            server SHALL be secured using Transport Layer Security (TLS) Protocol
+            Version 1.2 (RFC5246).
+          DESCRIPTION
+          id :bulk_data_server_tls_version
+
+          config(
+            inputs: { url: { name: :bulk_server_url } },
+            options: { minimum_allowed_version: OpenSSL::SSL::TLS1_2_VERSION }
+          )
+        end
+      end
+
+      group from: :bulk_data_group_export_v101
+      group from: :bulk_data_patient_export_v101
+      group from: :bulk_data_system_export_v101
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_group_export_test_group.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'group/bulk_data_group_export_group'
+require_relative 'group/bulk_data_group_export_cancel_group'
+require_relative 'group/bulk_data_group_export_validation_group'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataGroupTestGroup < Inferno::TestGroup
+      title 'Bulk Data Group API Tests'
+      id :bulk_data_group_export_v101
+      run_as_group
+
+      description %(
+          The Bulk Data Access API Tests evaluate the ability of a system (Bulk Data Server)
+          to support required Bulk Data Group $export operation.
+      )
+
+      group from: :bulk_data_group_export_group
+      group from: :bulk_data_group_export_validation
+      group from: :bulk_data_group_export_cancel_group
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_multiple_patients_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../bulk_export_validation_tester'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataMultiplePatientsTest < Inferno::Test
+      include BulkDataTestKit::BulkExportValidationTester
+
+      id :bulk_data_multiple_patients
+
+      title 'Export has at least two patients'
+      description <<~DESCRIPTION
+        This test verifies that the bulk data export has at least two patients.
+      DESCRIPTION
+      # link 'http://ndjson.org/'
+
+      run do
+        export_multiple_patients_check
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_ndjson_download_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../bulk_export_validation_tester'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataNDJSONDownloadTest < Inferno::Test
+      include BulkDataTestKit::BulkExportValidationTester
+
+      id :bulk_data_ndjson_download
+
+      title 'NDJSON download requires access token if requireAccessToken is true'
+      description <<~DESCRIPTION
+        If the requiresAccessToken field in the Complete Status body is set to true, the request SHALL include a valid#{' '}
+        access token.
+
+        [FHIR R4 Security](https://www.hl7.org/fhir/security.html#AccessDenied) and
+        [The OAuth 2.0 Authorization Framework: Bearer Token Usage](https://tools.ietf.org/html/rfc6750#section-3.1)
+        recommend using HTTP status code 401 for invalid token but also allow the actual result be controlled by policy#{' '}
+        and context.
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#file-request'
+
+      input :bulk_download_url
+      input :requires_access_token
+
+      run do
+        ndjson_download_requiresAccessToken_check(bulk_data_download_url: bulk_download_url,
+                                                  bulk_requires_access_token: requires_access_token)
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_no_auth_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../export_operation_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataExportNoAuthRejectTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportOperationTests
+      include BulkDataTestKit::ExportKickOffPerformer
+
+      id :bulk_data_no_auth_reject
+
+      title 'Bulk Data Server rejects $export request without authorization'
+      description <<~DESCRIPTION
+        The FHIR server SHALL limit the data returned to only those FHIR resources for which the client is authorized.
+
+        [FHIR R4 Security](https://www.hl7.org/fhir/security.html#AccessDenied) and
+        [The OAuth 2.0 Authorization Framework: Bearer Token Usage](https://tools.ietf.org/html/rfc6750#section-3.1)
+        recommend using HTTP status code 401 for invalid token but also allow the actual result be controlled by policy and context.
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#bulk-data-kick-off-request'
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type],
+          bulk_export_url: config.options[:bulk_export_url]
+        )
+      end
+
+      run do
+        rejects_without_authorization
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_output_check_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../export_operation_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataOutputCheckTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportOperationTests
+
+      id :bulk_data_output_check
+
+      title 'Bulk Data Server returns output with type and url for status complete'
+      description <<~DESCRIPTION
+        The value of output field is an array of file items with one entry for each generated file.
+        If no resources are returned from the kick-off request, the server SHOULD return an empty array.
+
+        Each file item SHALL contain the following fields:
+
+        * type - the FHIR resource type that is contained in the file.
+
+        Each file SHALL contain resources of only one type, but a server MAY create more than one file for each resource type returned.
+
+        * url - the path to the file. The format of the file SHOULD reflect that requested in the _outputFormat parameter of the initial kick-off request.
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#response---complete-status'
+
+      input :status_response
+
+      output :status_output, :bulk_download_url
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type]
+        )
+      end
+
+      run do
+        status_output, bulk_download_url = check_bulk_data_output(status_response)
+
+        output status_output:,
+               bulk_download_url:
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_patient_export_test_group.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'patient/bulk_data_patient_export_group'
+require_relative 'patient/bulk_data_patient_export_cancel_group'
+require_relative 'patient/bulk_data_patient_export_validation_group'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataPatientTestGroup < Inferno::TestGroup
+      title 'Bulk Data Patient API Tests'
+      id :bulk_data_patient_export_v101
+      run_as_group
+
+      description %(
+        The Bulk Data Access API Tests evaluate the ability of a system (Bulk Data Server)
+        to support required Bulk Data Patient $export operation.
+      )
+
+      group from: :bulk_data_patient_export_group
+      group from: :bulk_data_patient_export_validation
+      group from: :bulk_data_patient_export_cancel_group
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_smart_backend_services_group.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'smart_app_launch/smart_stu2_suite'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataSmartBackendServicesGroup < Inferno::TestGroup
+      title 'SMART Backend Services'
+      id :bulk_data_smart_backend_services
+      run_as_group
+      optional
+
+      group from: :smart_discovery_stu2,
+            config: {
+              inputs: { url: { name: :bulk_server_url } }
+            }
+
+      group from: :backend_services_authorization
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_status_check_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../export_operation_tests'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataStatusCheckTest < Inferno::Test
+      include BulkDataTestKit::BulkDataExportOperationTests
+
+      id :bulk_data_status_check
+
+      title 'Bulk Data Server returns "202 Accepted" or "200 OK" for status check'
+      description <<~DESCRIPTION
+        Clients SHOULD follow an exponential backoff approach when polling for status. Servers SHOULD respond with
+
+        * In-Progress Status: HTTP Status Code of 202 Accepted
+        * Complete Status: HTTP status of 200 OK and Content-Type header of application/json
+
+        The JSON object of Complete Status SHALL contain these required field:
+
+        * transactionTime, request, requiresAccessToken, output, and error
+      DESCRIPTION
+      # link 'http://hl7.org/fhir/uv/bulkdata/STU1.0.1/export/index.html#bulk-data-status-request'
+
+      input :polling_url
+
+      output :status_response, :requires_access_token
+
+      def self.properties
+        @properties ||= BulkDataTestKitProperties.new(
+          resource_type: config.options[:resource_type]
+        )
+      end
+
+      run do
+        requires_access_token, status_response = export_status_check_success(polling_url)
+
+        output(requires_access_token:)
+        output status_response:
+      end
+    end
+  end
+end

data/lib/bulk_data_test_kit/v1.0.1/bulk_data_system_export_test_group.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'system_export/bulk_data_system_export_group'
+require_relative 'system_export/bulk_data_system_export_cancel_group'
+require_relative 'system_export/bulk_data_system_export_validation_group'
+
+module BulkDataTestKit
+  module BulkDataV101
+    class BulkDataSystemExportTestGroup < Inferno::TestGroup
+      title 'Bulk Data System Level Export API Tests'
+      id :bulk_data_system_export_v101
+      run_as_group
+
+      description %(
+        The Bulk Data Access API Tests evaluate the ability of a system (Bulk Data Server)
+        to support required Bulk Data system $export operation.
+      )
+
+      group from: :bulk_data_system_export_group
+      group from: :bulk_data_system_export_validation
+      group from: :bulk_data_system_export_cancel_group
+    end
+  end
+end