ipa_test_kit 0.2.0

data/lib/ipa_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -0,0 +1,105 @@
+module IpaTestKit
+  class Generator
+    class TerminologyBindingMetadataExtractor
+      attr_accessor :profile_elements, :ig_resources, :resource
+
+      def initialize(profile_elements, ig_resources, resource)
+        self.profile_elements = profile_elements
+        self.ig_resources = ig_resources
+        self.resource = resource
+      end
+
+      def terminology_bindings
+        (element_terminology_bindings + extension_terminology_bindings).compact
+        # add_terminology_bindings_from_extensions
+        # profile_elements.select { |element| element.type&.first&.code == 'Extension' }
+        #   .each { |extension| add_terminology_bindings_from_extension(extension) }
+      end
+
+      def element_has_fixed_value?(element)
+        case element.type.first.code
+        when 'Quantity'
+          code = profile_elements.find { |e| e.path == "#{element.path}.code" }
+          system = profile_elements.find { |e| e.path == "#{element.path}.system" }
+          code&.fixedCode || system&.fixedUri
+        when 'code'
+          element.fixedCode.present?
+        end
+      end
+
+      def profile_elements_with_bindings
+        profile_elements
+          .select { |element| element.binding.present? }
+          .reject { |element| element_has_fixed_value? element }
+      end
+
+      def element_terminology_bindings
+        profile_elements_with_bindings.map do |element|
+          {
+            type: element.type.first.code,
+            strength: element.binding.strength,
+            # Goal.target.detail has an unbound binding
+            system: element.binding.valueSet&.split('|')&.first,
+            path: element.path.gsub('[x]', '').gsub("#{resource}.", '')
+          }
+        end
+      end
+
+      def extension_profile_elements
+        profile_elements
+          .select { |element| element.type&.first&.code == 'Extension' }
+          .select { |element| extension_profile_url(element).present? }
+      end
+
+      def extension_profile_url(extension)
+        extension.type.first.profile&.first
+      end
+
+      def extension_terminology_bindings
+        extension_profile_elements
+          .flat_map do |extension_profile_element|
+            url = extension_profile_url(extension_profile_element)
+            extension = ig_resources.profile_by_url(url)
+
+            elements = extension.snapshot.element
+            elements_with_bindings = elements.select do |element|
+              element.binding.present? && !element.id.include?('Extension.extension')
+            end
+
+            elements_with_bindings.map do |element|
+              {
+                type: element.type.first.code,
+                strength: element.binding.strength,
+                system: element.binding.valueSet&.split('|')&.first,
+                path: element.path.gsub('[x]', '').gsub('Extension.', ''),
+                extensions: [url]
+              }
+            end + nested_extension_terminology_bindings(elements, url)
+          end
+      end
+
+      def nested_extension_terminology_bindings(elements, extension_url)
+        nested_extensions = elements.select { |element| element.path == 'Extension.extension' }
+        nested_extensions.flat_map do |nested_extension|
+          nested_extension_element = elements.find { |element| element.id == "#{nested_extension.id}.url" }
+          next unless nested_extension_element.present?
+
+          nested_extension_url = nested_extension_element.fixedUri
+          nested_elements_with_bindings = elements.select do |element|
+            element.id.include?(nested_extension.id) && element.binding.present?
+          end
+
+          nested_elements_with_bindings.map do |element|
+            {
+              type: element.type.first.code,
+              strength: element.binding.strength,
+              system: element.binding.valueSet&.split('|')&.first,
+              path: element.path.gsub('[x]', '').gsub('Extension.extension.', ''),
+              extensions: [extension_url, nested_extension_url]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ipa_test_kit/generator/validation_test_generator.rb

@@ -0,0 +1,124 @@
+require_relative 'naming'
+require_relative 'special_cases'
+
+module IpaTestKit
+  class Generator
+    class ValidationTestGenerator
+      class << self
+        def generate(ig_metadata)
+          ig_metadata.groups
+            .reject { |group| SpecialCases.exclude_resource? group.resource }
+            .each do |group|
+              new(group).generate
+              next unless group.resource == 'MedicationRequest'
+
+              # The Medication validation test lives in the MedicationRequest
+              # group, so we need to pass in that group's metadata
+              medication_group_metadata = ig_metadata.groups.find { |group| group.resource == 'Medication' }
+              new(medication_group_metadata, group).generate
+            end
+        end
+      end
+
+      attr_accessor :group_metadata, :medication_request_metadata
+
+      def initialize(group_metadata, medication_request_metadata = nil)
+        self.group_metadata = group_metadata
+        self.medication_request_metadata = medication_request_metadata
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'validation.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(__dir__, '..', 'generated', directory_name)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def directory_name
+        Naming.snake_case_for_profile(medication_request_metadata || group_metadata)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def profile_url
+        group_metadata.profile_url
+      end
+
+      def profile_name
+        group_metadata.profile_name
+      end
+
+      def test_id
+        "ipa_010_#{profile_identifier}_validation_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        read_interaction[:expectation]
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+
+        test_metadata = {
+          id: test_id,
+          file_name: base_output_file_name
+        }
+
+        if resource_type == 'Medication'
+          medication_request_metadata.add_test(test_metadata)
+        else
+          group_metadata.add_test(test_metadata)
+        end
+      end
+
+      def description
+        <<~DESCRIPTION
+        #{description_intro}
+        It verifies the presence of mandatory elements and that elements with
+        required bindings contain appropriate values. CodeableConcept element
+        bindings will fail if none of their codings have a code/system belonging
+        to the bound ValueSet. Quantity, Coding, and code element bindings will
+        fail if their code/system are not found in the valueset.
+        DESCRIPTION
+      end
+
+      def description_intro
+        if resource_type == 'Medication'
+          <<~MEDICATION_INTRO
+          This test verifies resources returned from previous tests conform to
+          the [#{profile_name}](#{profile_url}).
+          MEDICATION_INTRO
+        else
+          <<~GENERIC_INTRO
+          This test verifies resources returned from the first search conform to
+          the [#{profile_name}](#{profile_url}).
+          GENERIC_INTRO
+        end
+      end
+    end
+  end
+end

data/lib/ipa_test_kit/generator.rb

@@ -0,0 +1,86 @@
+require 'fhir_models'
+
+require_relative 'ext/fhir_models'
+require_relative 'generator/ig_loader'
+require_relative 'generator/ig_metadata_extractor'
+require_relative 'generator/group_generator'
+require_relative 'generator/must_support_test_generator'
+require_relative 'generator/provenance_revinclude_search_test_generator'
+require_relative 'generator/read_test_generator'
+require_relative 'generator/reference_resolution_test_generator'
+require_relative 'generator/resource_list_generator'
+require_relative 'generator/search_test_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/validation_test_generator'
+
+module IpaTestKit
+  class Generator
+    attr_accessor :ig_resources, :ig_metadata
+
+    def generate
+      load_ig_package
+      extract_metadata
+      generate_resource_list
+      generate_search_tests
+      generate_read_tests
+      # TODO: generate_vread_tests
+      # TODO: generate_history_tests
+      generate_provenance_revinclude_search_tests
+      generate_validation_tests
+      generate_must_support_tests
+      generate_reference_resolution_tests
+
+      generate_groups
+
+      generate_suites
+    end
+
+    def extract_metadata
+      self.ig_metadata = IGMetadataExtractor.new(ig_resources).extract
+      File.open(File.join(__dir__, 'generated', 'metadata.yml'), 'w') do |file|
+        file.write(YAML.dump(ig_metadata.to_hash))
+      end
+    end
+
+    def load_ig_package
+      FHIR.logger = Logger.new('/dev/null')
+      self.ig_resources = IGLoader.new.load
+    end
+
+    def generate_resource_list
+      ResourceListGenerator.generate(ig_metadata)
+    end
+
+    def generate_reference_resolution_tests
+      ReferenceResolutionTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_must_support_tests
+      MustSupportTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_validation_tests
+      ValidationTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_read_tests
+      ReadTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_search_tests
+      SearchTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_provenance_revinclude_search_tests
+      ProvenanceRevincludeSearchTestGenerator.generate(ig_metadata)
+    end
+
+    def generate_groups
+      GroupGenerator.generate(ig_metadata)
+    end
+
+    def generate_suites
+      SuiteGenerator.generate(ig_metadata)
+    end
+  end
+end

data/lib/ipa_test_kit/must_support_test.rb

@@ -0,0 +1,146 @@
+require_relative 'fhir_resource_navigation'
+
+module IpaTestKit
+  module MustSupportTest
+    extend Forwardable
+    include FHIRResourceNavigation
+
+    def_delegators 'self.class', :metadata
+
+    def all_scratch_resources
+      scratch_resources[:all]
+    end
+
+    def perform_must_support_test(resources)
+      skip_if resources.blank?, "No #{resource_type} resources were found"
+
+      if (missing_elements(resources) + missing_slices(resources)).length.zero?
+        pass
+      end
+
+      skip "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
+           "provided #{resource_type} resource(s)"
+    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 must_support_extensions
+      metadata.must_supports[:extensions]
+    end
+
+    def missing_extensions(resources = [])
+      @missing_extensions ||=
+        must_support_extensions.select do |extension_definition|
+          resources.none? do |resource|
+            resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+          end
+        end
+    end
+
+    def must_support_elements
+      metadata.must_supports[:elements]
+    end
+
+    def missing_elements(resources = [])
+      @missing_elements ||=
+        must_support_elements.select do |element_definition|
+          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.reject { |key, _| key == '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
+    end
+
+    def must_support_slices
+      metadata.must_supports[:slices]
+    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 '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 'String'
+            element.is_a? String
+          else
+            element.is_a? FHIR.const_get(discriminator[:code])
+          end
+        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? { |value_definition| value_definition[:value] == el_found }
+
+            child_element_values_match =
+              child_element_value_definitions.present? ?
+                find_slice_by_values(el_found, child_element_value_definitions) : true
+
+            current_element_values_match && child_element_values_match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ipa_test_kit/read_test.rb

@@ -0,0 +1,62 @@
+module IpaTestKit
+  module ReadTest
+    def all_scratch_resources
+      scratch_resources[:all] ||= []
+    end
+
+    def perform_read_test(resources, reply_handler = nil)
+      skip_if resources.blank?, no_resources_skip_message
+
+      resources_to_read = readable_resources(resources)
+
+      assert resources_to_read.present?, "No #{resource_type} id found."
+
+      if config.options[:read_all_resources]
+        resources_to_read.each do |resource|
+          read_and_validate(resource)
+        end
+      else
+        read_and_validate(resources_to_read.first)
+      end
+    end
+
+    def readable_resources(resources)
+      resources
+        .select { |resource| resource.is_a?(resource_class) || resource.is_a?(FHIR::Reference) }
+        .select { |resource| (resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id).present? }
+        .compact
+        .uniq { |resource| resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id }
+    end
+
+    def read_and_validate(resource_to_read)
+      id = resource_id(resource_to_read)
+
+      fhir_read resource_type, id
+
+      assert_response_status(200)
+      assert_resource_type(resource_type)
+      assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
+
+      if resource_to_read.is_a? FHIR::Reference
+        all_scratch_resources << resource
+      end
+    end
+
+    def resource_id(resource)
+      resource.is_a?(FHIR::Reference) ? resource.reference.split('/').last : resource.id
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+      'Please use patients with more information.'
+    end
+
+    def bad_resource_id_message(expected_id)
+      "Expected resource to have id: `#{id}`, but found `#{resource.id}`"
+    end
+
+    def resource_class
+      FHIR.const_get(resource_type)
+    end
+  end
+end

data/lib/ipa_test_kit/reference_resolution_test.rb

@@ -0,0 +1,111 @@
+require_relative '../ipa_test_kit/generated/resource_list'
+
+module IpaTestKit
+  module ReferenceResolutionTest
+    include ResourceList
+
+    def perform_reference_resolution_test(resources)
+      skip_if resources.blank?, no_resources_skip_message
+
+      self.resolution_count = 0
+
+      resources.each do |resource|
+        break if resolution_count >= max_resolutions
+
+        validate_reference_resolutions(resource)
+      end
+
+      messages.uniq!
+      errors_found = messages.any? { |message| message[:type] == 'error' }
+
+      assert !errors_found, "Inferno was unable to resolve all IPA references"
+    end
+
+    def max_resolutions
+      50
+    end
+
+    def resolution_count
+      @resolution_count
+    end
+
+    def resolution_count=(count)
+      @resolution_count = count
+    end
+
+    def record_resolved_reference(reference)
+      self.resolution_count += 1
+      resolved_references.add?(reference.reference)
+    end
+
+    def resolved_references
+      scratch[:resolved_references] ||= Set.new
+    end
+
+    def no_resources_skip_message
+      "No #{resource_type} resources appear to be available. " \
+      'Please use patients with more information.'
+    end
+
+    def validate_reference_resolutions(resource)
+      problems = []
+
+      resource.each_element do |reference, meta, path|
+        next if meta['type'] != 'Reference'
+        next if reference.reference.blank?
+        next if resolved_references.include?(reference.reference)
+        break if resolution_count >= max_resolutions
+
+        if reference.contained?
+          # if reference_id is blank it is referring to itself, so we know it exists
+          next if reference.reference_id.blank?
+
+          unless resource.contained.any? { |contained_resource| contained_resource&.id == reference.reference_id }
+            messages << {
+              type: 'error',
+              message: "#{path} has contained reference to id '#{reference.reference_id}' that does not exist"
+            }
+          end
+
+          next
+        end
+
+        # Should potentially update valid? method in fhir_dstu2_models
+        # to check for this type of thing
+        # e.g. "patient/54520" is invalid (fhir_client resource_class method would expect "Patient/54520")
+        if reference.relative?
+          begin
+            reference.resource_class
+          rescue NameError
+            problems << "#{path} has invalid resource type in reference: #{reference.type}"
+            next
+          end
+        end
+        reference_type = reference.resource_type
+
+        begin
+          # TODO: this request isn't persisted
+          resolved_resource = reference.read(fhir_client)
+        rescue ClientException => e
+          # report error if the resource is a IPA resource type
+          messages << {
+            type: 'error',
+            message: "#{path} did not resolve: #{e}"
+          } if RESOURCE_LIST.include?(reference_type)
+
+          next
+        end
+
+        if resolved_resource&.resourceType == reference_type
+          record_resolved_reference(reference)
+        else
+          messages << {
+            type: 'error',
+            message: "Expected #{reference.reference} to refer to a #{reference_type} resource, " \
+                     "but found a #{resolved_resource&.resourceType} resource."
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ipa_test_kit/request_logger.rb

@@ -0,0 +1,46 @@
+module Inferno
+  module Utils
+    # @private
+    module Middleware
+      class RequestLogger
+        def log_response(response, start_time, end_time, exception = nil)
+          elapsed = end_time - start_time
+          status, _response_headers, body = response if response
+          status, = response if exception
+
+          logger.info("#{status} in #{elapsed.in_milliseconds} ms")
+          return unless body.present?
+
+          body = body.is_a?(Array) ? body.join : body
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+
+        def log_request(env)
+          method = env['REQUEST_METHOD']
+          scheme = env['rack.url_scheme']
+          host = env['HTTP_HOST']
+          path = env['REQUEST_URI']
+          query = env['rack.request.query_string']
+          body = env['rack.input']
+          body = body.instance_of?(Puma::NullIO) ? nil : body.string
+          query_string = query.blank? ? '' : "?#{query}"
+
+          logger.info("#{method} #{scheme}://#{host}#{path}#{query_string}")
+
+          return unless body.present?
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
+        end
+      end
+    end
+  end
+end