davinci_us_drug_formulary_test_kit 0.9.0

data/lib/davinci_us_drug_formulary_test_kit/generator/group_generator.rb

@@ -0,0 +1,181 @@
+require_relative 'naming'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class GroupGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.ordered_groups
+            .each { |group| new(group, base_output_dir).generate }
+        end
+      end
+
+      attr_accessor :group_metadata, :base_output_dir
+
+      def initialize(group_metadata, base_output_dir)
+        self.group_metadata = group_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'group.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def base_metadata_file_name
+        'metadata.yml'
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}Group"
+      end
+
+      def module_name
+        "USDF#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def title
+        group_metadata.title
+      end
+
+      def short_description
+        group_metadata.short_description
+      end
+
+      def output_file_name
+        File.join(base_output_dir, base_output_file_name)
+      end
+
+      def metadata_file_name
+        File.join(base_output_dir, profile_identifier, base_metadata_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def group_id
+        "usdf_#{group_metadata.reformatted_version}_#{profile_identifier}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def search_validation_resource_type
+        "#{resource_type} resources"
+      end
+
+      def profile_name
+        group_metadata.profile_name
+      end
+
+      def profile_url
+        group_metadata.profile_url
+      end
+
+      def optional?
+        false
+      end
+
+      def generate
+        File.write(output_file_name, output)
+        group_metadata.id = group_id
+        group_metadata.file_name = base_output_file_name
+        File.write(metadata_file_name, YAML.dump(group_metadata.to_hash))
+      end
+
+      def test_id_list
+        @test_id_list ||=
+          group_metadata.tests.map { |test| test[:id] }
+      end
+
+      def test_file_list
+        @test_file_list ||=
+          group_metadata.tests.map do |test|
+            name_without_suffix = test[:file_name].delete_suffix('.rb')
+            name_without_suffix.start_with?('..') ? name_without_suffix : "#{profile_identifier}/#{name_without_suffix}"
+          end
+      end
+
+      def required_searches
+        group_metadata.searches.select { |search| search[:expectation] == 'SHALL' }
+      end
+
+      def search_param_name_string
+        required_searches
+          .map { |search| search[:names].join(' + ') }
+          .map { |names| "* #{names}" }
+          .join("\n")
+      end
+
+      def search_description
+        return '' if required_searches.blank?
+
+        <<~SEARCH_DESCRIPTION
+          ## Searching
+          This test sequence will first perform each required search associated
+          with this resource. This sequence will perform searches with the
+          following parameters:
+
+          #{search_param_name_string}
+
+          ### Search Parameters
+          The first search uses the selected resources from the prior launch
+          sequence. Any subsequent searches will look for its parameter values
+          from the results of the first search. If a value cannot be found this way, the search is skipped.
+
+          ### Search Validation
+          Inferno will retrieve up to the first 20 bundle pages of the reply for
+          #{search_validation_resource_type} and save them for subsequent tests. Each of
+          these resources is then checked to see if it matches the searched
+          parameters in accordance with [FHIR search
+          guidelines](https://www.hl7.org/fhir/search.html).
+        SEARCH_DESCRIPTION
+      end
+
+      def description
+        <<~DESCRIPTION
+          # Background
+
+          The USDF #{title} sequence verifies that the system under test is
+          able to provide correct responses for #{resource_type} queries. These queries
+          must contain resources conforming to the #{profile_name} as
+          specified in the USDF #{group_metadata.version} Implementation Guide.
+
+          # Testing Methodology
+          #{search_description}
+
+          ## Must Support
+          Each profile contains elements marked as "must support". This test
+          sequence expects to see each of these elements at least once. If at
+          least one cannot be found, the test will fail. The test will look
+          through the #{resource_type} resources found in the first test for these
+          elements.
+
+          ## Profile Validation
+          Each resource returned from the first search is expected to conform to
+          the [#{profile_name}](#{profile_url}). Each element is checked against
+          teminology binding and cardinality requirements.
+
+          Elements with a required binding are validated against their bound
+          ValueSet. If the code/system in the element is not part of the ValueSet,
+          then the test will fail.
+
+          ## Reference Validation
+          At least one instance of each external reference in elements marked as
+          "must support" within the resources provided by the system must resolve.
+          The test will attempt to read each reference found and will fail if no
+          read succeeds.
+        DESCRIPTION
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/group_metadata.rb

@@ -0,0 +1,79 @@
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class GroupMetadata
+      ATTRIBUTES = [
+        :name,
+        :class_name,
+        :version,
+        :reformatted_version,
+        :resource,
+        :profile_url,
+        :profile_name,
+        :profile_version,
+        :title,
+        :short_description,
+        :interactions,
+        # :operations,
+        :searches,
+        :search_definitions,
+        :include_params,
+        # :revincludes,
+        :must_supports,
+        :mandatory_elements,
+        # :bindings,
+        :references,
+        :tests,
+        :id,
+        :file_name,
+        :delayed_references
+      ].freeze
+
+      ATTRIBUTES.each { |name| attr_accessor name }
+
+      def initialize(metadata)
+        metadata.each do |key, value|
+          raise "Unknown attribute #{key}" unless ATTRIBUTES.include? key
+
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def delayed?
+        false
+      end
+
+      def add_test(id:, file_name:)
+        self.tests ||= []
+
+        test_metadata = {
+          id:,
+          file_name:
+        }
+
+        if delayed? && id.include?('read')
+          self.tests.unshift(test_metadata)
+        else
+          self.tests << test_metadata
+        end
+      end
+
+      def to_hash
+        ATTRIBUTES.each_with_object({}) { |key, hash| hash[key] = send(key) unless send(key).nil? }
+      end
+
+      def add_delayed_references(delayed_profiles, ig_resources)
+        self.delayed_references =
+          references
+            .select { |reference| (reference[:profiles] & delayed_profiles).present? }
+            .map do |reference|
+              profile_urls = (reference[:profiles] & delayed_profiles)
+              delayed_resources = profile_urls.map { |url| ig_resources.resource_for_profile(url) }
+              {
+                path: reference[:path].gsub("#{resource}.", ''),
+                resources: delayed_resources
+              }
+            end
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/group_metadata_extractor.rb

@@ -0,0 +1,329 @@
+require_relative 'group_metadata'
+require_relative 'ig_metadata'
+require_relative 'must_support_metadata_extractor'
+require_relative 'search_metadata_extractor'
+require_relative 'terminology_binding_metadata_extractor'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class GroupMetadataExtractor
+      attr_accessor :resource_capabilities, :profile_url, :ig_metadata, :ig_resources
+
+      def initialize(resource_capabilities, profile_url, ig_metadata, ig_resources)
+        self.resource_capabilities = resource_capabilities
+        self.profile_url = profile_url
+        self.ig_metadata = ig_metadata
+        self.ig_resources = ig_resources
+      end
+
+      def group_metadata
+        @group_metadata ||=
+          GroupMetadata.new(group_metadata_hash)
+      end
+
+      def group_metadata_hash
+        @group_metadata_hash ||=
+          {
+            name:,
+            class_name:,
+            version:,
+            reformatted_version:,
+            resource:,
+            profile_url:,
+            profile_name:,
+            profile_version:,
+            title:,
+            short_description:,
+            interactions:,
+            # operations: operations,
+            searches:, # searches: searches,
+            search_definitions:, # search_definitions: search_definitions
+            include_params:,
+            # revincludes: revincludes,
+            must_supports:,
+            mandatory_elements:,
+            # bindings: bindings,
+            references:
+          }
+
+        mark_mandatory_and_must_support_searches
+        handle_special_cases
+
+        @group_metadata_hash
+      end
+
+      def mark_mandatory_and_must_support_searches
+        searches.each do |search|
+          search[:names_not_must_support_or_mandatory] = search[:names].reject do |name|
+            full_paths =
+              search_definitions[name.to_sym][:full_paths]
+                .map { |path| path.gsub(/\AResource\./, "#{resource}.") } # Fix for Resource.meta.*
+
+            any_must_support_elements = must_supports[:elements].any? do |element|
+              full_must_support_paths = ["#{resource}.#{element[:original_path]}", "#{resource}.#{element[:path]}"]
+
+              full_paths.any? do |path|
+                # allow for non-choice, choice types, and _id
+                name == '_id' ||
+                  full_must_support_paths.include?(path) ||
+                  full_must_support_paths.include?("#{path}[x]")
+              end
+            end
+
+            any_must_support_slices = must_supports[:slices].any? do |slice|
+              # only handle type slices because that is all we need for now
+              # for a slice like Observation.effective[x]:effectiveDateTime, the search parameter's expression could be
+              # either Observation.effective or Observation.effectiveDateTime.
+              if slice[:discriminator] && slice[:discriminator][:type] == 'type'
+                full_must_support_path = "#{resource}.#{slice[:path].sub('[x]', slice[:discriminator][:code])}"
+                base_must_support_path = "#{resource}.#{slice[:path].sub('[x]', '')}"
+
+                full_paths.intersection([full_must_support_path, base_must_support_path]).present?
+              else
+                false
+              end
+            end
+
+            any_must_support_extensions = must_supports[:extensions].any? do |extension|
+              full_must_support_paths = ["#{resource}.#{extension[:path]}.where(url='#{extension[:url]}').value"]
+
+              full_paths.any? { |path| full_must_support_paths.include?(path) }
+            end
+
+            any_mandatory_elements = mandatory_elements.any? do |element|
+              full_paths.include?(element)
+            end
+
+            any_must_support_elements ||
+              any_must_support_slices ||
+              any_must_support_extensions ||
+              any_mandatory_elements
+          end
+
+          search[:must_support_or_mandatory] = search[:names_not_must_support_or_mandatory].empty?
+        end
+      end
+
+      ### BEGIN SPECIAL CASES ###
+
+      def first_search_params
+        @first_search_params ||=
+          if resource == 'Location'
+            ['_id']
+          elsif resource == 'Basic'
+            ['code']
+          else
+            ['status']
+          end
+      end
+
+      def handle_special_cases
+        set_first_search
+        filter_drug_values
+        add_must_support_choices
+      end
+
+      def set_first_search
+        search = searches.find { |param| param[:names] == first_search_params }
+        return if search.nil?
+
+        searches.delete(search)
+        searches.unshift(search)
+      end
+
+      def filter_drug_values
+        search_definitions[:doseform][:values] = [] unless search_definitions[:doseform].nil?
+
+        return if search_definitions[:code].nil?
+        return unless search_definitions[:code][:full_paths] == ['MedicationKnowledge.code']
+
+        search_definitions[:code][:values] = []
+      end
+
+      def add_must_support_choices
+        choices = []
+        case profile.type
+        when 'Location'
+          choices << { paths: ['address'],
+                       extension_ids: ['Location.extension:region'] }
+        end
+
+        must_supports[:choices] = choices if choices.present?
+      end
+
+      ### END SPECIAL CASES ###
+
+      def profile
+        @profile ||= ig_resources.profile_by_url(profile_url)
+      end
+
+      def profile_elements
+        @profile_elements ||= profile.snapshot.element
+      end
+
+      def base_name
+        profile_url.split('StructureDefinition/').last
+      end
+
+      def name
+        base_name.tr('-', '_')
+      end
+
+      def class_name
+        base_name
+          .split('-')
+          .map(&:capitalize)
+          .join
+          .gsub('USDF', "USDF#{ig_metadata.reformatted_version}")
+          .concat('Sequence')
+      end
+
+      def version
+        ig_metadata.ig_version
+      end
+
+      def reformatted_version
+        ig_metadata.reformatted_version
+      end
+
+      def resource
+        resource_capabilities.type
+      end
+
+      def profile_name
+        binding.pry if profile.nil?
+        profile.title.gsub('  ', ' ')
+      end
+
+      def profile_version
+        profile.version
+      end
+
+      def title
+        profile.title.gsub(/US\s*Core\s*/, '').gsub(/\s*Profile/, '').strip
+      end
+
+      def short_description
+        "Verify support for the server capabilities required by the #{profile_name}."
+      end
+
+      def interactions
+        @interactions ||=
+          resource_capabilities.interaction.map do |interaction|
+            {
+              code: interaction.code,
+              expectation: interaction.extension.first.valueCode # TODO: fix expectation extension finding
+            }
+          end
+      end
+
+      # def operations
+      #   @operations ||=
+      #     resource_capabilities.operation.map do |operation|
+      #       {
+      #         code: operation.name,
+      #         expectation: operation.extension.first.valueCode # TODO: fix expectation extension finding
+      #       }
+      #     end
+      # end
+
+      def search_metadata_extractor
+        @search_metadata_extractor ||=
+          SearchMetadataExtractor.new(resource_capabilities, ig_resources, resource, profile_elements)
+      end
+
+      def searches
+        @searches ||= search_metadata_extractor.searches
+      end
+
+      def search_definitions
+        @search_definitions ||= search_metadata_extractor.search_definitions
+      end
+
+      def include_params
+        resource_capabilities.searchInclude || []
+      end
+
+      # def revincludes
+      #   resource_capabilities.searchRevInclude || []
+      # end
+
+      # def terminology_binding_metadata_extractor
+      #   @terminology_binding_metadata_extractor ||=
+      #     TerminologyBindingMetadataExtractor.new(profile_elements, ig_resources, resource)
+      # end
+
+      # def bindings
+      #   @bindings ||=
+      #     terminology_binding_metadata_extractor.terminology_bindings
+      # end
+
+      def must_support_metadata_extractor
+        @must_support_metadata_extractor ||=
+          MustSupportMetadataExtractor.new(profile_elements, profile, resource, ig_resources)
+      end
+
+      def must_supports
+        @must_supports ||=
+          must_support_metadata_extractor.must_supports
+      end
+
+      def mandatory_elements
+        @mandatory_elements ||=
+          profile_elements
+            .select { |element| element.min.positive? && parents_are_mandatory?(element) }
+            .map(&:path)
+            .uniq
+      end
+
+      def parents_are_mandatory?(element)
+        return true if element.path.count('.') < 2
+
+        parent_path = element.path.split('.')[0..-2].join('.')
+        parent_element = profile_elements.find { |profile_element| profile_element.path == parent_path }
+
+        parent_element&.min&.positive? && parents_are_mandatory?(parent_element)
+      end
+
+      def references
+        @references ||= element_references + extension_references
+      end
+
+      def element_references
+        profile_elements
+          .select { |element| element.type&.first&.code == 'Reference' }
+          .map do |reference_definition|
+          {
+            path: reference_definition.path,
+            profiles: reference_definition.type.first.targetProfile
+          }
+        end
+      end
+
+      def extension_references
+        profile_elements
+          .select { |element| element.type.any? { |type| type.code == 'Extension' && type.profile.present? } }
+          .map do |element|
+          extension_url = element.type.first.profile.first
+
+          target_profiles =
+            ig_resources
+              .profile_by_url(extension_url)
+              &.snapshot
+              &.element
+              &.find { |profile_element| profile_element.id == 'Extension.value[x]:valueReference' }
+              &.type
+              &.first
+              &.targetProfile
+
+          next if target_profiles.blank?
+
+          {
+            path: "#{element.path}.where(url='#{extension_url}').valueReference",
+            target_profiles:
+          }
+        end.compact
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/ig_loader.rb

@@ -0,0 +1,77 @@
+require 'active_support/all'
+require 'fhir_models'
+require 'pathname'
+require 'rubygems/package'
+require 'zlib'
+require_relative 'ig_resources'
+
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class IGLoader
+      attr_accessor :ig_file_name
+
+      def initialize(ig_file_name)
+        self.ig_file_name = ig_file_name
+      end
+
+      def ig_resources
+        @ig_resources ||= IGResources.new
+      end
+
+      def load
+        load_ig
+        load_standalone_resources
+      end
+
+      def load_ig
+        tar = Gem::Package::TarReader.new(
+          Zlib::GzipReader.open(ig_file_name)
+        )
+
+        tar.each do |entry|
+          next if entry.directory?
+
+          file_name = entry.full_name.split('/').last
+
+          next unless file_name.end_with? '.json'
+
+          next unless entry.full_name.start_with? 'package/'
+
+          begin
+            resource = FHIR.from_contents(entry.read)
+            next if resource.nil?
+          rescue StandardError
+            puts "#{file_name} does not appear to be a FHIR resource."
+            next
+          end
+
+          ig_resources.add(resource)
+        end
+
+        ig_resources
+      end
+
+      def load_standalone_resources
+        ig_directory = ig_file_name.chomp('.tgz')
+
+        Dir.glob(File.join(ig_directory, '*.json')).each do |file_path|
+          resource = FHIR.from_contents(File.read(file_path))
+          next if resource.nil?
+
+          if resource.resourceType == 'Bundle' && !resource.entry.nil?
+            resource_arr = resource.entry
+            resource_arr.each do |entry|
+              ig_resources.add(entry.resource)
+            end
+          end
+        rescue StandardError
+          file_name = file_path.split('/').last
+          puts "#{file_name} does not appear to be a FHIR resource."
+          next
+        end
+
+        ig_resources
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generator/ig_metadata.rb

@@ -0,0 +1,33 @@
+module DaVinciUSDrugFormularyTestKit
+  class Generator
+    class IGMetadata
+      attr_accessor :ig_version, :groups
+
+      def reformatted_version
+        @reformatted_version ||= ig_version.delete('.').gsub('-', '_')
+      end
+
+      def ordered_groups
+        @ordered_groups ||= groups
+      end
+
+      def delayed_profiles
+        @delayed_profiles ||=
+          delayed_groups.map(&:profile_url)
+      end
+
+      def postprocess_groups(ig_resources)
+        groups.each do |group|
+          group.add_delayed_references(delayed_profiles, ig_resources)
+        end
+      end
+
+      def to_hash
+        {
+          ig_version:,
+          groups: groups.map(&:to_hash)
+        }
+      end
+    end
+  end
+end