carin_for_blue_button_test_kit 0.9.0

data/lib/carin_for_blue_button_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -0,0 +1,109 @@
+module CarinForBlueButtonTestKit
+    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)
+  
+              # 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/carin_for_blue_button_test_kit/generator/validation_test_generator.rb

@@ -0,0 +1,137 @@
+require_relative 'naming'
+
+module CarinForBlueButtonTestKit
+  class Generator
+    class ValidationTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+            .each do |group|
+              new(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
+        "c4bb_#{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
+        "CARIN4BB#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        read_interaction[:expectation]
+      end
+
+      def specific_resource_type
+        case profile_identifier
+        when 'explanation_of_benefit_inpatient_institutional'
+          return "ExplanationOfBenefitInpatientInstitutional"
+        when 'explanation_of_benefit_oral'
+          return "ExplanationOfBenefitOral"
+        when 'explanation_of_benefit_outpatient_institutional'
+          return "ExplanationOfBenefitOutpatientInstitutional"
+        when 'explanation_of_benefit_pharmacy'
+          return "ExplanationOfBenefitPharmacy"
+        when 'explanation_of_benefit_professional_non_clinician'
+          return "ExplanationOfBenefitProfessionalNonClinician"
+        else
+          return self.resource_type
+        end
+      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
+        }
+          group_metadata.add_test(**test_metadata)
+      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
+          <<~GENERIC_INTRO
+          This test verifies resources returned from the first search conform to
+          the [#{profile_name}](#{profile_url}).
+          Systems must demonstrate at least one valid example in order to pass this test.
+          GENERIC_INTRO
+      end
+    end
+  end
+end

data/lib/carin_for_blue_button_test_kit/generator/value_extractor.rb

@@ -0,0 +1,50 @@
+module CarinForBlueButtonTestKit
+    class Generator
+      class ValueExactor
+        attr_accessor :ig_resources, :resource
+  
+        def initialize(ig_resources, resource)
+          self.ig_resources = ig_resources
+          self.resource = resource
+        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)
+          value_set(the_element)&.compose&.include&.reject { |code| code.concept.nil? }
+        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

data/lib/carin_for_blue_button_test_kit/generator.rb

@@ -0,0 +1,90 @@
+require 'inferno/ext/fhir_models'
+
+require_relative 'generator/ig_loader'
+require_relative 'generator/ig_metadata_extractor'
+require_relative 'generator/resource_list_generator'
+require_relative 'generator/validation_test_generator'
+require_relative 'generator/group_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/read_test_generator'
+require_relative 'generator/must_support_test_generator'
+require_relative 'generator/search_test_generator'
+
+module CarinForBlueButtonTestKit
+    class Generator
+        def self.generate
+            ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'carin_for_blue_button_test_kit', 'igs', '*.tgz'))
+      
+            ig_packages.each do |ig_package|
+              new(ig_package).generate
+            end
+        end
+
+        attr_accessor :ig_resources, :ig_metadata, :ig_file_name
+
+        def initialize(ig_file_name)
+            self.ig_file_name = ig_file_name
+        end
+
+        def generate
+            puts "Generating tests for IG #{File.basename(ig_file_name)}"
+            load_ig_package
+            extract_metadata
+            generate_resource_list
+            generate_read_tests
+            generate_validation_tests
+            generate_must_support_tests
+            generate_search_tests
+
+            generate_groups
+            generate_suites
+        end
+
+        def load_ig_package
+            FHIR.logger = Logger.new('/dev/null')
+            self.ig_resources = IGLoader.new(ig_file_name).load
+        end
+
+        def extract_metadata
+            self.ig_metadata = IGMetadataExtractor.new(ig_resources).extract
+      
+            FileUtils.mkdir_p(base_output_dir)
+            File.open(File.join(base_output_dir, 'metadata.yml'), 'w') do |file|
+              file.write(YAML.dump(ig_metadata.to_hash))
+            end
+        end
+
+        def base_output_dir
+            File.join(__dir__, 'generated', ig_metadata.ig_version)
+        end
+
+        def generate_resource_list
+            ResourceListGenerator.generate(ig_metadata, base_output_dir)
+        end
+        
+        def generate_validation_tests
+            ValidationTestGenerator.generate(ig_metadata, base_output_dir)
+        end
+
+        def generate_read_tests
+            ReadTestGenerator.generate(ig_metadata, base_output_dir)
+        end
+
+        def generate_groups
+            GroupGenerator.generate(ig_metadata, base_output_dir)
+        end
+
+        def generate_suites
+            SuiteGenerator.generate(ig_metadata, base_output_dir)
+        end
+
+        def generate_must_support_tests
+            MustSupportTestGenerator.generate(ig_metadata, base_output_dir)
+        end
+
+        def generate_search_tests
+            SearchTestGenerator.generate(ig_metadata, base_output_dir)
+        end
+      
+    end
+end

data/lib/carin_for_blue_button_test_kit/must_support_test.rb

@@ -0,0 +1,211 @@
+require_relative 'fhir_resource_navigation'
+
+module CarinForBlueButtonTestKit
+  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"
+
+      missing_elements(resources)
+      missing_slices(resources)
+      missing_extensions(resources)
+
+      handle_must_support_choices if metadata.must_supports[:choices].present?
+
+      if (missing_elements + missing_slices + missing_extensions).length.zero?
+        pass
+      end
+
+      skip "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[:name]) }
+        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? { |extension_id| missing_extensions.none? { |extension| extension[:id] == extension_id} } ||
+        choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == 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|
+            resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+          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|
+          resources.none? do |resource|
+            path = element_definition[:path] #.delete_suffix('[x]')
+            value_found = find_a_value_at(resource.source_hash, 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
+
+      @missing_elements
+    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.source_hash, 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.to_s] == discriminator[:code] && coding[:system.to_s] == discriminator[:system]
+          end
+        when 'patternCoding'
+          coding_path = discriminator[:path].present? ? discriminator[:path] : ''
+          find_a_value_at(element, coding_path) do |coding|
+            coding[:code.to_s] == discriminator[:code] && coding[:system.to_s] == discriminator[:system]
+          end
+        when 'patternIdentifier'
+          find_a_value_at(element, discriminator[:path]) { |identifier| identifier[:system.to_s] == 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
+            element.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.to_s]) }
+        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/carin_for_blue_button_test_kit/read_test.rb

@@ -0,0 +1,51 @@
+module CarinForBlueButtonTestKit
+    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
+  
+        if config.options[:read_all_resources]
+          resources.each do |id|
+            fhir_read(resource_type, id)
+            read_and_validate(resource)
+          end
+        else
+          fhir_read(resource_type, resources.first)
+          read_and_validate(resource)
+        end
+      end
+  
+      def read_and_validate(resource_to_read)
+        id = resource_id(resource_to_read)
+
+        assert_response_status(200) 
+        assert_resource_type(resource_type, resource: resource_to_read)
+        assert resource.id.present? && resource.id == id, bad_resource_id_message(id)
+  
+        if resource_to_read.is_a?(FHIR::Model)
+          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: `#{expected_id.inspect}`, but found `#{resource.id.inspect}`"
+      end
+  
+      def resource_class
+        FHIR.const_get(resource_type)
+      end
+    end
+  end
+