davinci_plan_net_test_kit 0.9.0

data/lib/davinci_plan_net_test_kit/generator/special_cases.rb

@@ -0,0 +1,92 @@
+module DaVinciPlanNetTestKit
+  class Generator
+    module SpecialCases
+      RESOURCES_TO_EXCLUDE = [].freeze
+
+      PROFILES_TO_EXCLUDE = [].freeze
+
+      GROUP_SORT_ORDER = ["plannet_Endpoint", 
+                          "plannet_InsurancePlan", 
+                          "plannet_OrganizationAffiliation",
+                          "plannet_PractitionerRole",
+                          "plannet_Practitioner",
+                          "plannet_HealthcareService",
+                          "plannet_Location",
+                          "plannet_Network",
+                          "plannet_Organization"].freeze
+
+      PARAMETERLESS_FILTER_DESCRIPTION = {
+        "Plan-Net Network" => "In order to gather only Organization instances expected to conform to the Plan-Net Network profile, instances where `type` does not equal `ntwk` will be discarded. ",
+        "Plan-Net Organization" => "In order to gather only Organization instances expected to conform to the Plan-Net Organization profile, instances where `type` equals `ntwk` will be discarded. "
+      }.freeze
+
+      class << self
+        def exclude_group?(group)
+          RESOURCES_TO_EXCLUDE.include?(group.resource)
+        end
+
+        def group_index(group_name)
+          GROUP_SORT_ORDER.index(group_name)
+        end
+
+        def has_explicit_group_order()
+          GROUP_SORT_ORDER.size > 0
+        end
+
+        def has_parameterless_filter?(profile_name)
+          PARAMETERLESS_FILTER_DESCRIPTION.key?(profile_name)
+        end
+
+        def parameterless_filter_description(profile_name)
+          PARAMETERLESS_FILTER_DESCRIPTION[profile_name]
+        end
+
+        def run_special_cases(ig_metadata)
+          fix_network_must_support(ig_metadata)
+          fix_revincludes_for_organization(ig_metadata)
+        end
+
+        def fix_network_must_support(ig_metadata)
+          # The Network profile is based on USCore Organization, since there was no contradiction between the USCore profile 
+          # and the Plan-Net requirements. However, the NPI and CLIA identifier types, which are Must-Support, are clearly 
+          # intended for provider organizations only and are not expected to be populated for other organization types.
+          network_group = ig_metadata.groups.find { |group| group.name == 'plannet_Network'}
+          adjusted_must_supports = network_group.must_supports[:slices].dup.delete_if {|slice| slice[:name] == 'Organization.identifier:NPI'}
+          network_group.must_supports[:slices] = adjusted_must_supports
+        end
+
+        def fix_revincludes_for_organization(ig_metadata)
+          # Revincludes are listed in the capability statement at the resource level,
+          # but resources that support multiple profiles do not make the distinction of which tests are for which
+          # This separates the revinclude lists for Network and Organization profiles from the Organization resource 
+          # For Plan Net PDEX v1.1.0
+          organization_group = ig_metadata.groups.find { |group| group.name == 'plannet_Organization'}
+          network_group = ig_metadata.groups.find { |group| group.name == 'plannet_Network'}
+
+          network_revincludes, corrected_revinclude_list = organization_group.revincludes.partition do |revinclude|
+            revinclude.split(/:/)[1] == "network"
+          end
+          
+          organization_group.revincludes = corrected_revinclude_list
+          network_group.revincludes = network_revincludes
+        end
+      end
+    end
+  end
+  
+  module SpecialCases
+    def self.filter_instance_for_parameterless_gathering?(profile_url, instance)
+      case profile_url
+      when 'http://hl7.org/fhir/us/davinci-pdex-plan-net/StructureDefinition/plannet-Organization'
+        # filter if we see the network type
+        instance.type.reduce(false) { |outer_result, a_type| outer_result || a_type.coding.reduce(false) { |result, a_coding| result || (a_coding.code == 'ntwk' && a_coding.system == 'http://hl7.org/fhir/us/davinci-pdex-plan-net/CodeSystem/OrgTypeCS') } }
+      when 'http://hl7.org/fhir/us/davinci-pdex-plan-net/StructureDefinition/plannet-Network'
+        # filter unless we see the network type
+        instance.type.reduce(true) { |outer_result, a_type| outer_result && a_type.coding.reduce(true) { |result, a_coding| result && !(a_coding.code == 'ntwk' && a_coding.system == 'http://hl7.org/fhir/us/davinci-pdex-plan-net/CodeSystem/OrgTypeCS') } }
+      else
+        false
+      end
+    end
+  end
+
+end

data/lib/davinci_plan_net_test_kit/generator/suite_generator.rb

@@ -0,0 +1,93 @@
+require_relative 'naming'
+require_relative 'special_cases'
+
+module DaVinciPlanNetTestKit
+  class Generator
+    class SuiteGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          new(ig_metadata, base_output_dir).generate
+        end
+      end
+
+      attr_accessor :ig_metadata, :base_output_dir
+
+      def initialize(ig_metadata, base_output_dir)
+        self.ig_metadata = ig_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def version_specific_message_filters
+        []
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'suite.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "davinci_plan_net_test_suite.rb"
+      end
+
+      def class_name
+        "DaVinciPlanNetServerTestSuite"
+      end
+
+      def module_name
+        "DaVinciPlanNetServer#{ig_metadata.reformatted_version.upcase}"
+      end
+
+      def output_file_name
+        File.join(base_output_dir, base_output_file_name)
+      end
+
+      def suite_id
+        "davinci_plan_net_server_#{ig_metadata.reformatted_version}"
+      end
+
+      def title
+        "DaVinci Plan Net #{ig_metadata.ig_version} Server Test Suite"
+      end
+
+      def validator_env_name
+        "#{ig_metadata.reformatted_version.upcase}_VALIDATOR_URL"
+      end
+
+      def ig_link
+        "https://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1"
+      end
+
+      def generate
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+      end
+
+      def groups
+        ig_metadata.ordered_groups
+          .reject { |group| SpecialCases.exclude_group? group }
+      end
+
+      def group_id_list
+        @group_id_list ||=
+          groups.map(&:id)
+      end
+
+      def group_file_list
+        @group_file_list ||=
+          groups.map { |group| group.file_name.delete_suffix('.rb') }
+      end
+
+      def capability_statement_file_name
+        "../../custom_groups/#{ig_metadata.ig_version}/capability_statement_group"
+      end
+
+      def capability_statement_group_id
+        "davinci_plan_net_#{ig_metadata.reformatted_version}_capability_statement"
+      end
+
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -0,0 +1,120 @@
+module DaVinciPlanNetTestKit
+  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 element_has_optional_binding_slice?(element)
+        element.sliceName.present? && element.min == 0
+      end
+
+      def profile_elements_with_bindings
+        profile_elements
+          .select { |element| element.binding.present? && element.binding.strength == 'required'}
+          .reject { |element| element_has_fixed_value?(element) || element_has_optional_binding_slice?(element) }
+      end
+
+
+
+      def element_terminology_bindings
+        profile_elements_with_bindings.map do |element|
+          binding = {
+            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}.", '')
+          }
+
+          if element.sliceName.present? && element.min > 0
+            binding[:required_binding_slice] = true
+          end
+
+          binding
+        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)
+
+            # TODO: Temporaray fix for extension defined out of US Core. FI-1623
+            next if extension.nil?
+
+            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/davinci_plan_net_test_kit/generator/validation_test_generator.rb

@@ -0,0 +1,140 @@
+require_relative 'naming'
+require_relative 'special_cases'
+
+module DaVinciPlanNetTestKit
+  class Generator
+    class ValidationTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+            .reject { |group| SpecialCases.exclude_group? group }
+            .each do |group|
+              new(group, base_output_dir: base_output_dir).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, base_output_dir: base_output_dir).generate
+            end
+        end
+      end
+
+      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir
+
+      def initialize(group_metadata, medication_request_metadata = nil, base_output_dir:)
+        self.group_metadata = group_metadata
+        self.medication_request_metadata = medication_request_metadata
+        self.base_output_dir = base_output_dir
+      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(base_output_dir, 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 profile_version
+        group_metadata.profile_version
+      end
+
+      def test_id
+        "davinci_plan_net_#{group_metadata.reformatted_version}_#{profile_identifier}_validation_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
+      end
+
+      def module_name
+        "DaVinciPlanNet#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        read_interaction[:expectation]
+      end
+
+      def skip_if_empty
+        # Return true if a system must demonstrate at least one example of the resource type.
+        # This drives omit vs. skip result statuses in this test.
+        resource_type != 'Medication'
+      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}](#{group_metadata.versioned_profile_url}).
+          MEDICATION_INTRO
+        else
+          <<~GENERIC_INTRO
+          This test verifies resources returned from the first search conform to
+          the [#{profile_name}](#{group_metadata.versioned_profile_url}).
+          Systems must demonstrate at least one valid example in order to pass this test.
+          GENERIC_INTRO
+        end
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/value_extractor.rb

@@ -0,0 +1,117 @@
+module DaVinciPlanNetTestKit
+  class Generator
+    class ValueExactor
+      attr_accessor :ig_resources, :resource, :profile_elements
+
+      def initialize(ig_resources, resource, profile_elements)
+        self.ig_resources = ig_resources
+        self.resource = resource
+        self.profile_elements = profile_elements
+      end
+
+      def values_from_slicing(profile_element, type)
+        (
+          values_from_fixed_codes(profile_element, type) +
+          values_from_pattern_coding(profile_element, type) +
+          values_from_pattern_codeable_concept(profile_element, type)
+        ).uniq
+      end
+
+      def values_from_required_binding(profile_element)
+        return [] unless profile_element&.max == '*'
+
+        profile_elements
+          .select do |element|
+            element.path == profile_element.path && element.binding&.strength == 'required'
+          end
+          .map { |element| values_from_value_set_binding(element) }
+          .flatten.compact
+      end
+
+      def values_from_fixed_codes(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do
+            |element| element.path == "#{profile_element.path}.coding.code" && element.fixedCode.present?
+          end
+          .map { |element| element.fixedCode }
+      end
+
+      def values_from_pattern_coding(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do |element|
+            element.path == "#{profile_element.path}.coding" && element.patternCoding.present?
+          end
+          .map { |element| element.patternCoding.code }
+      end
+
+      def values_from_pattern_codeable_concept(profile_element, type)
+        return [] unless type == 'CodeableConcept'
+
+        profile_elements
+          .select do |element|
+            element.path == profile_element.path && element.patternCodeableConcept.present? && element.min > 0
+          end
+          .map { |element| element.patternCodeableConcept.coding.first.code }
+      end
+
+      def value_set_binding(the_element)
+        the_element&.binding
+      end
+
+      def value_set(the_element)
+        ig_resources.value_set_by_url(value_set_binding(the_element)&.valueSet)
+      end
+
+      def bound_systems(the_element)
+        bound_systems_from_valueset(value_set(the_element))
+      end
+
+      def bound_systems_from_valueset(value_set)
+        systems = value_set&.compose&.include&.map do |include|
+          if include.concept.present?
+            include
+          elsif include.system.present? && include.filter&.empty? # Cannot process intensional value set with filters
+            ig_resources.code_system_by_url(include.system)
+          elsif include.valueSet.present?
+            include.valueSet.map do |vs|
+              a_value_set = ig_resources.value_set_by_url(vs)
+              bound_systems_from_valueset(a_value_set)
+            end
+          end
+        end&.flatten&.compact
+
+        systems
+      end
+
+      def values_from_value_set_binding(the_element)
+        bound_systems = bound_systems(the_element)
+
+        return [] if bound_systems.blank?
+
+        bound_systems.flat_map { |system| system.concept.map { |code| code.code } }.uniq
+      end
+
+      def fhir_metadata(current_path)
+        FHIR.const_get(resource)::METADATA[current_path]
+      end
+
+      def values_from_resource_metadata(paths)
+        values = []
+
+        paths.each do |current_path|
+          current_metadata = fhir_metadata(current_path)
+
+          if current_metadata&.dig('valid_codes').present?
+            values = values + current_metadata['valid_codes'].values.flatten
+          end
+        end
+
+        values
+      end
+    end
+  end
+end