davinci_pas_test_kit 0.9.0

data/lib/davinci_pas_test_kit/mock_server.rb

@@ -0,0 +1,189 @@
+require_relative 'user_input_response'
+
+module DaVinciPASTestKit
+  # Serve responses to PAS requests
+  #
+  # Note that there are numerous expected validation issues that can safely be ignored.
+  # See here for full list: https://hl7.org/fhir/us/davinci-pas/STU2/qa.html#suppressed
+  module MockServer
+    def token_response(request, _test = nil, _test_result = nil)
+      # Placeholder for a more complete mock token endpoint
+      request.response_body = { access_token: SecureRandom.hex, token_type: 'bearer', expires_in: 300 }.to_json
+      request.status = 200
+    end
+
+    def claim_response(request, test = nil, test_result = nil)
+      request.status = 200
+      request.response_headers = { 'Content-Type': 'application/json' }
+
+      user_inputted_response = UserInputResponse.user_inputted_response(test, test_result)
+      if test.present? && test_result.present? && user_inputted_response.present?
+        request.response_body = user_inputted_response
+        return
+      end
+
+      operation = request&.url&.split('$')&.last
+      req_bundle = FHIR.from_contents(request&.request_body)
+      claim_entry = req_bundle&.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
+      root_url = base_url(claim_entry&.fullUrl)
+      return unless ['submit', 'inquire'].include?(operation) && claim_entry.present?
+
+      claim_response = mock_claim_response(claim_entry.resource, req_bundle, operation, root_url)
+
+      res_bundle = FHIR::Bundle.new(
+        id: SecureRandom.uuid,
+        meta: FHIR::Meta.new(profile: if operation == 'submit'
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-response-bundle'
+                                      else
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-response-bundle'
+                                      end),
+        timestamp: Time.now.utc.iso8601,
+        type: 'collection',
+        entry: [
+          FHIR::Bundle::Entry.new(fullUrl: "urn:uuid:#{claim_response.id}",
+                                  resource: claim_response)
+        ]
+      )
+
+      res_bundle.entry.concat(referenced_entities(claim_response, req_bundle.entry, root_url))
+
+      request.response_body = res_bundle.to_json
+      request.status = 200
+      request.response_headers = { 'Content-Type': 'application/json' }
+    end
+
+    # Note that references from the claim to other resources in the bundle need to be changed to absolute URLs
+    # if they are relative, because the ClaimResponse's fullUrl is a urn:uuid
+    #
+    # @private
+    def mock_claim_response(claim, bundle, operation, root_url)
+      return FHIR::ClaimResponse.new(id: SecureRandom.uuid) if claim.blank?
+
+      now = Time.now.utc
+
+      FHIR::ClaimResponse.new(
+        id: SecureRandom.uuid,
+        meta: FHIR::Meta.new(profile: if operation == 'submit'
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claimresponse'
+                                      else
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claiminquiryresponse'
+                                      end),
+        identifier: claim.identifier,
+        type: claim.type,
+        status: claim.status,
+        use: claim.use,
+        patient: absolute_reference(claim.patient, bundle.entry, root_url),
+        created: now.iso8601,
+        insurer: absolute_reference(claim.insurer, bundle.entry, root_url),
+        requestor: absolute_reference(claim.provider, bundle.entry, root_url),
+        outcome: 'complete',
+        item: claim.item.map do |item|
+          FHIR::ClaimResponse::Item.new(
+            extension: [
+              FHIR::Extension.new(
+                url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-itemPreAuthIssueDate',
+                valueDate: now.strftime('%Y-%m-%d')
+              ),
+              FHIR::Extension.new(
+                url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-itemPreAuthPeriod',
+                valuePeriod: FHIR::Period.new(start: now.strftime('%Y-%m-%d'),
+                                              end: (now + 1.month).strftime('%Y-%m-%d'))
+              )
+            ],
+            itemSequence: item.sequence,
+            adjudication: [
+              FHIR::ClaimResponse::Item::Adjudication.new(
+                extension: [
+                  FHIR::Extension.new(
+                    url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewAction',
+                    extension: [
+                      FHIR::Extension.new(
+                        url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewActionCode',
+                        valueCodeableConcept: FHIR::CodeableConcept.new(
+                          coding: [
+                            FHIR::Coding.new(
+                              system: 'https://codesystem.x12.org/005010/306',
+                              code: 'A1',
+                              display: 'Certified in total'
+                            )
+                          ]
+                        )
+                      )
+                    ]
+                  )
+                ],
+                category: FHIR::CodeableConcept.new(
+                  coding: [
+                    FHIR::Coding.new(system: 'http://terminology.hl7.org/CodeSystem/adjudication', code: 'submitted')
+                  ]
+                )
+              )
+            ]
+          )
+        end
+      )
+    end
+
+    def extract_client_id(request)
+      URI.decode_www_form(request.request_body).to_h['client_id']
+    end
+
+    # Header expected to be a bearer token of the form "Bearer: <token>"
+    def extract_bearer_token(request)
+      request.request_header('Authorization')&.value&.split&.last
+    end
+
+    def extract_token_from_query_params(request)
+      request.query_parameters['token']
+    end
+
+    # Drop the last two segments of a URL, i.e. the resource type and ID of a FHIR resource
+    # e.g. http://example.org/fhir/Patient/123 -> http://example.org/fhir
+    # @private
+    def base_url(url)
+      return unless url.start_with?('http://', 'https://')
+
+      # Drop everything after the second to last '/', ignoring a trailing slash
+      url.sub(%r{/[^/]*/[^/]*(/)?\z}, '')
+    end
+
+    # @private
+    def referenced_entities(resource, entries, root_url)
+      matches = []
+      attributes = resource&.source_hash&.keys
+      attributes.each do |attr|
+        value = resource.send(attr.to_sym)
+        if value.is_a?(FHIR::Reference) && value.reference.present?
+          match = find_matching_entry(value.reference, entries, root_url)
+          if match.present? && matches.none?(match)
+            value.reference = match.fullUrl
+            matches.concat([match], referenced_entities(match.resource, entries, root_url))
+          end
+        elsif value.is_a?(Array) && value.all? { |elmt| elmt.is_a?(FHIR::Model) }
+          value.each { |val| matches.concat(referenced_entities(val, entries, root_url)) }
+        end
+      end
+
+      matches
+    end
+
+    # @private
+    def absolute_reference(ref, entries, root_url)
+      url = find_matching_entry(ref&.reference, entries, root_url)&.fullUrl
+      ref.reference = url if url
+      ref
+    end
+
+    # @private
+    def find_matching_entry(ref, entries, root_url = '')
+      ref = "#{root_url}/#{ref}" if relative_reference?(ref) && root_url&.present?
+
+      entries&.find { |entry| entry&.fullUrl == ref }
+    end
+
+    # @private
+    def relative_reference?(ref)
+      ref&.count('/') == 1
+    end
+  end
+end

data/lib/davinci_pas_test_kit/must_support_test.rb

@@ -0,0 +1,267 @@
+require_relative 'fhir_resource_navigation'
+
+module DaVinciPASTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def reset_variables
+      @missing_elements = @missing_slices = @missing_extensions = nil
+    end
+
+    def tagged_resources(tag)
+      resources = []
+      load_tagged_requests(tag)
+      return resources if requests.empty?
+
+      requests.each do |req|
+        begin
+          bundle = FHIR.from_contents(req.request_body)
+        rescue StandardError
+          next
+        end
+
+        next unless bundle.is_a?(FHIR::Bundle)
+
+        resources << bundle
+        entry_resources = bundle.entry.map(&:resource)
+        resources.concat(entry_resources)
+      end
+
+      resources
+    end
+
+    def all_must_support_errors
+      @all_must_support_errors ||= []
+    end
+
+    def validate_must_support
+      assert all_must_support_errors.empty?, all_must_support_errors.join("\n")
+    end
+
+    def perform_must_support_test(resources)
+      assert resources.present?, "No #{resource_type} resources were found"
+
+      missing_elements(resources)
+      missing_slices(resources)
+      missing_extensions(resources)
+
+      handle_must_support_choices if metadata.must_supports[:choices].present?
+
+      return unless (missing_elements + missing_slices + missing_extensions).compact.reject(&:empty?).present?
+
+      all_must_support_errors << "Could not find #{missing_must_support_strings.join(', ')} " \
+                                 "in the #{resources.length} provided #{resource_type} resource(s)."
+
+      all_must_support_errors.reject! { |err| err.downcase.include?('x12') }
+      reset_variables
+
+      # pass if (missing_elements + missing_slices + missing_extensions).empty?
+
+      # assert false, "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
+      #               "provided #{resource_type} resource(s)"
+    end
+
+    def handle_must_support_choices
+      missing_elements.delete_if do |element|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_extensions.delete_if do |extension|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
+        is_any_choice_supported?(choices)
+      end
+
+      missing_slices.delete_if do |slice|
+        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:slice_id]) }
+        is_any_choice_supported?(choices)
+      end
+    end
+
+    def is_any_choice_supported?(choices)
+      choices.present? &&
+        (
+          choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
+          choices[:extension_ids]&.any? do |extension_id|
+            missing_extensions.none? do |extension|
+              extension[:id] == extension_id
+            end
+          end ||
+          choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:slice_id] == slice_name } }
+        )
+    end
+
+    def missing_must_support_strings
+      missing_elements.map { |element_definition| missing_element_string(element_definition) } +
+        missing_slices.map { |slice_definition| slice_definition[:name] } +
+        missing_extensions.map { |extension_definition| extension_definition[:id] }
+    end
+
+    def missing_element_string(element_definition)
+      if element_definition[:fixed_value].present?
+        "#{element_definition[:path]}:#{element_definition[:fixed_value]}"
+      else
+        element_definition[:path]
+      end
+    end
+
+    def exclude_uscdi_only_test?
+      config.options[:exclude_uscdi_only_test] == true
+    end
+
+    def must_support_extensions
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:extensions].reject { |extension| extension[:uscdi_only] }
+      else
+        metadata.must_supports[:extensions]
+      end
+    end
+
+    def missing_extensions(resources = [])
+      @missing_extensions ||=
+        must_support_extensions.select do |extension_definition|
+          resources.none? do |resource|
+            path = extension_definition[:path]
+            if extension_definition[:path] == 'extension'
+              resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+            else
+              extension = find_a_value_at(resource, path) do |el|
+                el.url == extension_definition[:url]
+              end
+
+              extension&.url == extension_definition[:url]
+            end
+          end
+        end
+    end
+
+    def must_support_elements
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:elements].reject { |element| element[:uscdi_only] }
+      else
+        metadata.must_supports[:elements]
+      end
+    end
+
+    def missing_elements(resources = [])
+      @missing_elements ||=
+        must_support_elements.select do |element_definition|
+          # PAS: The MS Claim.supportingInfo slices do not have timing[x]
+          next if resource_type == 'Claim' && element_definition[:path] == 'supportingInfo.timing[x]'
+
+          resources.none? do |resource|
+            path = element_definition[:path] # .delete_suffix('[x]')
+            value_found = find_a_value_at(resource, path) do |value|
+              value_without_extensions =
+                value.respond_to?(:to_hash) ? value.to_hash.except('extension') : value
+
+              (value_without_extensions.present? || value_without_extensions == false) &&
+                (element_definition[:fixed_value].blank? || value == element_definition[:fixed_value])
+            end
+            # Note that false.present? => false, which is why we need to add this extra check
+            value_found.present? || value_found == false
+          end
+        end
+      @missing_elements.compact
+    end
+
+    def must_support_slices
+      if exclude_uscdi_only_test?
+        metadata.must_supports[:slices].reject { |slice| slice[:uscdi_only] }
+      else
+        metadata.must_supports[:slices]
+      end
+    end
+
+    def missing_slices(resources = [])
+      @missing_slices ||=
+        must_support_slices.select do |slice|
+          resources.none? do |resource|
+            path = slice[:path] # .delete_suffix('[x]')
+            find_slice(resource, path, slice[:discriminator]).present?
+          end
+        end
+    end
+
+    def find_slice(resource, path, discriminator)
+      find_a_value_at(resource, path) do |element|
+        case discriminator[:type]
+        when 'patternCodeableConcept'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternCoding'
+          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
+          find_a_value_at(element, coding_path) do |coding|
+            coding.code == discriminator[:code] && coding.system == discriminator[:system]
+          end
+        when 'patternIdentifier'
+          find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
+        when 'value'
+          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+          find_slice_by_values(element, values)
+        when 'type'
+          case discriminator[:code]
+          when 'Date'
+            begin
+              Date.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'DateTime'
+            begin
+              DateTime.parse(element)
+            rescue ArgumentError
+              false
+            end
+          when 'String'
+            element.is_a? String
+          else
+            res = element.try(:resource) || element
+            res.is_a? FHIR.const_get(discriminator[:code])
+          end
+        when 'requiredBinding'
+          coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
+          find_a_value_at(element, coding_path) { |coding| discriminator[:values].include?(coding.code) }
+        end
+      end
+    end
+
+    def find_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      Array.wrap(element).find do |el|
+        path_prefixes.all? do |path_prefix|
+          value_definitions_for_path =
+            value_definitions
+              .select { |value_definition| value_definition[:path].first == path_prefix }
+              .each { |value_definition| value_definition[:path].shift }
+          find_a_value_at(el, path_prefix) do |el_found|
+            child_element_value_definitions, current_element_value_definitions =
+              value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+            current_element_values_match = current_element_value_definitions.all? do |value_definition|
+              (value_definition[:value].present? && value_definition[:value] == el_found) ||
+                (value_definition[:value].blank? && el_found.present?)
+            end
+
+            child_element_values_match =
+              if child_element_value_definitions.present?
+                find_slice_by_values(el_found, child_element_value_definitions)
+              else
+                true
+              end
+
+            current_element_values_match && child_element_values_match
+          end
+        end
+      end
+    end
+  end
+end