onc_certification_g10_test_kit 2.0.0.rc1

data/lib/onc_certification_g10_test_kit/bulk_export_validation_tester.rb

@@ -0,0 +1,171 @@
+require_relative 'profile_guesser'
+
+module ONCCertificationG10TestKit
+  module BulkExportValidationTester
+    include USCoreTestKit::MustSupportTest
+    include ProfileGuesser
+
+    attr_reader :metadata
+
+    MAX_NUM_COLLECTED_LINES = 100
+    MIN_RESOURCE_COUNT = 2
+
+    def observation_metadata
+      [
+        USCoreTestKit::PediatricBmiForAgeGroup.metadata,
+        USCoreTestKit::PediatricWeightForHeightGroup.metadata,
+        USCoreTestKit::ObservationLabGroup.metadata,
+        USCoreTestKit::PulseOximetryGroup.metadata,
+        USCoreTestKit::SmokingstatusGroup.metadata,
+        USCoreTestKit::HeadCircumferenceGroup.metadata,
+        USCoreTestKit::BpGroup.metadata,
+        USCoreTestKit::BodyheightGroup.metadata,
+        USCoreTestKit::BodytempGroup.metadata,
+        USCoreTestKit::BodyweightGroup.metadata,
+        USCoreTestKit::HeartrateGroup.metadata,
+        USCoreTestKit::ResprateGroup.metadata
+      ]
+    end
+
+    def diagnostic_metadata
+      [USCoreTestKit::DiagnosticReportLabGroup.metadata, USCoreTestKit::DiagnosticReportNoteGroup.metadata]
+    end
+
+    def determine_metadata
+      return observation_metadata if resource_type == 'Observation'
+      return diagnostic_metadata if resource_type == 'DiagnosticReport'
+
+      if resource_type == 'Location' || resource_type == 'Medication'
+        return Array.wrap(USCoreTestKit::USCoreTestSuite.metadata.find do |meta|
+                            meta.resource == resource_type
+                          end)
+      end
+      ["USCoreTestKit::#{resource_type}Group".constantize.metadata]
+    end
+
+    def metadata_list
+      @metadata_list ||= determine_metadata
+    end
+
+    def patient_ids_seen
+      scratch[:patient_ids_seen] ||= []
+    end
+
+    def build_headers(use_token)
+      headers = { accept: 'application/fhir+ndjson' }
+      headers.merge!({ authorization: "Bearer #{bearer_token}" }) if use_token == 'true'
+      headers
+    end
+
+    def stream_ndjson(endpoint, headers, process_chunk_line, process_response)
+      hanging_chunk = String.new
+
+      process_body = proc { |chunk|
+        hanging_chunk << chunk
+        chunk_by_lines = hanging_chunk.lines
+
+        hanging_chunk = chunk_by_lines.pop || String.new
+
+        chunk_by_lines.each do |elem|
+          process_chunk_line.call(elem)
+        end
+      }
+
+      stream(process_body, endpoint, headers: headers)
+
+      process_chunk_line.call(hanging_chunk)
+      process_response.call(response)
+    end
+
+    def predefined_device_type?(resource) # rubocop:disable Metrics/CyclomaticComplexity
+      return true if bulk_device_types_in_group.blank?
+
+      expected = Set.new(bulk_device_types_in_group.split(',').map(&:strip))
+
+      actual = resource&.type&.coding&.filter_map do |coding|
+        coding.code if coding.system.nil? || coding.system == 'http://snomed.info/sct'
+      end
+
+      (expected & actual).any?
+    end
+
+    def determine_profile(resource)
+      return if resource.resourceType == 'Device' && !predefined_device_type?(resource)
+
+      guess_profile(resource)
+    end
+
+    def validate_conformance(resources)
+      metadata_list.each do |meta|
+        skip_if resources[meta.profile_url].blank?,
+                "No #{resource_type} resources found that conform to profile: #{meta.profile_url}."
+        @metadata = meta
+        @missing_elements = nil
+        @missing_slices = nil
+        begin
+          perform_must_support_test(resources[meta.profile_url])
+        rescue Inferno::Exceptions::PassException
+          next
+        end
+      end
+    end
+
+    def check_file_request(url) # rubocop:disable Metrics/CyclomaticComplexity
+      line_count = 0
+      resources = Hash.new { |h, k| h[k] = [] }
+
+      process_line = proc { |line|
+        next unless lines_to_validate.blank? ||
+                    line_count < lines_to_validate.to_i ||
+                    (resource_type == 'Patient' && patient_ids_seen.length < MIN_RESOURCE_COUNT)
+
+        line_count += 1
+
+        begin
+          resource = FHIR.from_contents(line)
+        rescue StandardError
+          skip "Server response at line \"#{line_count}\" is not a processable FHIR resource."
+        end
+
+        skip_if resource.resourceType != resource_type,
+                "Resource type \"#{resource.resourceType}\" at line \"#{line_count}\" does not match type " \
+                "defined in output \"#{resource_type}\""
+
+        profile_url = determine_profile(resource)
+        resources[profile_url] << resource
+        scratch[:patient_ids_seen] = patient_ids_seen | [resource.id] if resource_type == 'Patient'
+
+        skip_if !resource_is_valid?(resource: resource, profile_url: profile_url),
+                "Resource at line \"#{line_count}\" does not conform to profile \"#{profile_url}\"."
+      }
+
+      process_headers = proc { |response|
+        value = (response[:headers].find { |header| header.name.downcase == 'content-type' })&.value
+        unless value&.start_with?('application/fhir+ndjson')
+          skip "Content type must have 'application/fhir+ndjson' but found '#{value}'"
+        end
+      }
+
+      stream_ndjson(url, build_headers(requires_access_token), process_line, process_headers)
+      validate_conformance(resources)
+
+      line_count
+    end
+
+    def perform_bulk_export_validation
+      skip_if status_output.blank?, 'Could not verify this functionality when Bulk Status Output is not provided'
+      skip_if (requires_access_token == 'true' && bearer_token.blank?),
+              'Could not verify this functionality when Bearer Token is required and not provided'
+
+      file_list = JSON.parse(status_output).select { |file| file['type'] == resource_type }
+      skip_if file_list.empty?, "No #{resource_type} resource file item returned by server."
+
+      success_count = 0
+      file_list.each do |file|
+        success_count += check_file_request(file['url'])
+      end
+
+      pass "Successfully validated #{success_count} #{resource_type} resource(s)."
+    end
+  end
+end

data/lib/onc_certification_g10_test_kit/configuration_checker.rb

@@ -0,0 +1,104 @@
+require_relative '../inferno/terminology/tasks/check_built_terminology'
+
+module ONCCertificationG10TestKit
+  class ConfigurationChecker
+    EXPECTED_VALIDATOR_VERSION = '2.1.0'.freeze
+
+    def configuration_messages
+      validator_version_message + terminology_messages
+    end
+
+    def terminology_checker
+      @terminology_checker ||= Inferno::Terminology::Tasks::CheckBuiltTerminology.new
+    end
+
+    def mismatched_value_sets
+      terminology_checker.mismatched_value_sets
+    end
+
+    def validator_url
+      @validator_url ||= G10CertificationSuite.find_validator(:default).url
+    end
+
+    def validator_version_message
+      response = Faraday.get "#{validator_url}/version"
+      version = response.body
+
+      if version == EXPECTED_VALIDATOR_VERSION
+        [{
+          type: 'info',
+          message: "FHIR validator is the expected version `#{EXPECTED_VALIDATOR_VERSION}`"
+        }]
+      else
+        [{
+          type: 'error',
+          message: "Expected FHIR validator version `#{EXPECTED_VALIDATOR_VERSION}`, but found `#{version}`"
+        }]
+      end
+    rescue StandardError => e
+      [{
+        type: 'error',
+        message: "Unable to connect to Validator: `#{e.message}`"
+      }]
+    end
+
+    def terminology_messages # rubocop:disable Metrics/CyclomaticComplexity
+      success_messages = []
+      warning_messages = []
+      error_messages = []
+      messages = []
+      terminology_checker.expected_manifest.each do |expected_value_set|
+        url = expected_value_set[:url]
+        actual_value_set = terminology_checker.new_value_set(url)
+
+        if actual_value_set == expected_value_set
+          success_messages << "* `#{url}`: #{actual_value_set[:count]} codes"
+        elsif actual_value_set.nil?
+          error_messages << "* `#{url}`: Not loaded"
+        elsif terminology_checker.class::MIME_TYPE_SYSTEMS.include? url
+          warning_messages <<
+            "* `#{url}`: Expected codes: #{expected_value_set[:count]} Actual codes: #{actual_value_set[:count]}"
+        else
+          error_messages <<
+            "* `#{url}`: Expected codes: #{expected_value_set[:count]} Actual codes: #{actual_value_set[:count]}"
+        end
+      end
+
+      if success_messages.present?
+        messages << {
+          type: 'info',
+          message:
+            "The following value sets and code systems have been properly loaded:\n#{success_messages.join("\n")}"
+        }
+      end
+
+      if warning_messages.present?
+        warning_message = <<~WARNING
+          Mime-type based terminology did not exactly match. This can be the
+          result of using a slightly different version of the `mime-types-data`
+          gem and does not reflect a problem with the terminology build as long
+          as the expected and actual number of codes are close to each other.
+        WARNING
+        messages << {
+          type: 'warning',
+          message: warning_message + warning_messages.join("\n")
+        }
+      end
+
+      if error_messages.present?
+        error_message = <<~ERROR
+          There is a problem with the terminology resources. See the README for
+          the [G10 Certification Test Kit
+          README](https://github.com/inferno-framework/g10-certification-test-kit#terminology-support)
+          for instructions on building the required terminology resources:\n
+        ERROR
+        messages << {
+          type: 'error',
+          message: error_message + error_messages.join("\n")
+        }
+      end
+
+      messages
+    end
+  end
+end

data/lib/onc_certification_g10_test_kit/export_kick_off_performer.rb

@@ -0,0 +1,12 @@
+module ONCCertificationG10TestKit
+  module ExportKickOffPerformer
+    def perform_export_kick_off_request(use_token: true)
+      skip_if use_token && bearer_token.blank?, 'Could not verify this functionality when bearer token is not set'
+
+      headers = { accept: 'application/fhir+json', prefer: 'respond-async' }
+      headers.merge!({ authorization: "Bearer #{bearer_token}" }) if use_token
+
+      get("Group/#{group_id}/$export", client: :bulk_server, name: :export, headers: headers)
+    end
+  end
+end