davinci_pas_test_kit 0.9.0

data/lib/davinci_pas_test_kit/generator/resource_list_generator.rb

@@ -0,0 +1,59 @@
+module DaVinciPASTestKit
+  class Generator
+    class ResourceListGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          @ig_metadata = ig_metadata
+
+          FileUtils.mkdir_p(base_output_dir)
+          File.write(File.join(base_output_dir, base_output_file_name), output)
+        end
+
+        def resource_list
+          @ig_metadata.groups.map(&:title).uniq
+        end
+
+        def resource_supported_profiles
+          dict = {}
+          @ig_metadata.groups.each do |group|
+            dict[group.resource] ||= []
+            dict[group.resource] << group.profile_url
+          end
+          dict
+        end
+
+        def resource_list_string
+          resource_list.map { |resource| "      '#{resource}'" }.join(",\n")
+        end
+
+        def module_name
+          "PAS#{@ig_metadata.reformatted_version.upcase}"
+        end
+
+        def read_interaction(group_metadata)
+          group_metadata.interactions.find { |interaction| interaction[:code] == 'read' } || {}
+        end
+
+        def submit_operation(group_metadata)
+          group_metadata.operations.find { |operation| operation[:code] == '$submit' } || {}
+        end
+
+        def inquiry_operation(group_metadata)
+          group_metadata.operations.find { |operation| operation[:code] == '$inquire' } || {}
+        end
+
+        def template
+          @template ||= File.read(File.join(__dir__, 'templates', 'resource_list.rb.erb'))
+        end
+
+        def output
+          ERB.new(template).result(binding)
+        end
+
+        def base_output_file_name
+          'resource_list.rb'
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/suite_generator.rb

@@ -0,0 +1,94 @@
+require_relative 'naming'
+
+module DaVinciPASTestKit
+  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 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
+        'server_suite.rb'
+      end
+
+      def class_name
+        'ServerSuite'
+      end
+
+      def module_name
+        "DaVinciPAS#{ig_metadata.reformatted_version.upcase}"
+      end
+
+      def output_file_name
+        File.join(base_output_dir, base_output_file_name)
+      end
+
+      def suite_id
+        "davinci_pas_server_suite_#{ig_metadata.reformatted_version}"
+      end
+
+      def title
+        "Da Vinci PAS Server Suite #{ig_metadata.ig_version}"
+      end
+
+      def ig_link
+        case ig_metadata.ig_version
+        when 'v2.0.1'
+          'https://hl7.org/fhir/us/davinci-pas/STU2/'
+        else
+          'https://hl7.org/fhir/us/davinci-pas/history.html'
+        end
+      end
+
+      def generate
+        File.write(output_file_name, output)
+      end
+
+      def groups
+        ig_metadata.use_case_groups
+      end
+
+      def group_id_list
+        @group_id_list ||= groups.map { |group| group[:id] }
+          .reject { |id| id.include?('client') }
+          .reject { |id| id.include?('must_support') }
+      end
+
+      def group_file_list
+        @group_file_list ||= groups.map { |group| group[:file_name].delete_suffix('.rb') }
+          .reject { |name| name.include?('client') }
+      end
+
+      def error_group_file_name
+        "../../custom_groups/#{ig_metadata.ig_version}/pas_error_group"
+      end
+
+      def error_group_id
+        "pas_#{ig_metadata.reformatted_version}_error_group"
+      end
+
+      def must_support_group_id
+        @must_support_group_id ||= groups.map { |group| group[:id] }
+          .reject { |id| id.include?('client') }
+          .find { |id| id.include?('must_support') }
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/terminology_binding_metadata_extractor.rb

@@ -0,0 +1,108 @@
+module DaVinciPASTestKit
+  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/davinci_pas_test_kit/generator/validation_test_generator.rb

@@ -0,0 +1,181 @@
+require 'pry'
+require_relative 'naming'
+
+module DaVinciPASTestKit
+  class Generator
+    class ValidationTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ['server', 'client'].each do |system|
+            if system == 'server'
+              ig_metadata.bundle_groups.each do |group|
+                new(group, system, base_output_dir:).generate
+              end
+            else
+              ig_metadata.bundle_groups.each do |group|
+                case group.profile_name
+                when 'PAS Request Bundle'
+                  new(group, system, base_output_dir:).generate
+                when 'PAS Inquiry Request Bundle'
+                  new(group, system, 'pended_inquiry', base_output_dir:).generate
+                when 'PAS Response Bundle'
+                  ['denial', 'pended'].each do |workflow|
+                    new(group, system, workflow, base_output_dir:).generate
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir, :system, :workflow
+
+      def initialize(group_metadata, system, workflow = nil, medication_request_metadata = nil, base_output_dir:)
+        self.group_metadata = group_metadata
+        self.system = system
+        self.workflow = workflow
+        self.medication_request_metadata = medication_request_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        temp = system == 'server' ? 'validation.rb.erb' : 'validation_client.rb.erb'
+        @template ||= File.read(File.join(__dir__, 'templates', temp))
+      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
+        return 'client_tests' if system == 'client'
+
+        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 formatted_workflow
+        workflow.to_s.split('_').first.to_s
+      end
+
+      def test_id
+        pref = "pas_#{system}_#{group_metadata.reformatted_version}_#{formatted_workflow}".delete_suffix('_')
+        "#{pref}_#{profile_identifier}_validation_test"
+      end
+
+      def class_name
+        pref = "#{system.capitalize}#{formatted_workflow.camelize}"
+        "#{pref}#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
+      end
+
+      def module_name
+        "DaVinciPAS#{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 request_type
+        Naming.request_type_for_bundle_or_claim[profile_name]
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.write(output_file_name, output)
+
+        test_metadata = {
+          id: test_id,
+          file_name: base_output_file_name
+        }
+        group_metadata.add_test(**test_metadata)
+      end
+
+      def title
+        pref = user_input? ? '[USER INPUT VALIDATION] ' : ''
+        "#{pref}#{group_metadata.title} is valid"
+      end
+
+      def user_input?
+        (system == 'server' && request_type.include?('request')) ||
+          (system == 'client' && request_type.include?('response'))
+      end
+
+      def description
+        <<~DESCRIPTION
+          #{system == 'server' ? description_intro_server : description_intro_client}
+          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.
+
+          Note that because X12 value sets are not public, elements bound to value
+          sets containing X12 codes are not validated.
+        DESCRIPTION
+      end
+
+      def description_intro_server
+        <<~GENERIC_INTRO
+          This test validates the conformity of the
+          #{request_type.include?('request') ? 'user input' : "server's response"} to the
+          [#{profile_name}](#{profile_url}) structure#{request_type.include?('request') ? ', ensuring subsequent tests can accurately simulate content.' : '.'}
+          It also checks that other conformance requirements defined in the [PAS Formal
+          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
+          such as the presence of all referenced instances within the bundle and the
+          conformance of those instances to the appropriate profiles, are met.
+        GENERIC_INTRO
+      end
+
+      def description_intro_client
+        <<~GENERIC_INTRO
+          This test validates the conformity of the
+          #{request_type.include?('response') ? 'user input' : "client's request"} to the
+          [#{profile_name}](#{profile_url}) structure.
+          It also checks that other conformance requirements defined in the [PAS Formal
+          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
+          such as the presence of all referenced instances within the bundle and the
+          conformance of those instances to the appropriate profiles, are met.
+        GENERIC_INTRO
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/value_extractor.rb

@@ -0,0 +1,48 @@
+module DaVinciPASTestKit
+  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) }.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)
+
+          values += current_metadata['valid_codes'].values.flatten if current_metadata&.dig('valid_codes').present?
+        end
+
+        values
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator.rb

@@ -0,0 +1,80 @@
+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/operation_test_generator'
+require_relative 'generator/group_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/must_support_test_generator'
+
+module DaVinciPASTestKit
+  class Generator
+    def self.generate
+      ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'davinci_pas_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_validation_tests
+      generate_operation_tests
+      generate_must_support_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.write(File.join(base_output_dir, 'metadata.yml'), YAML.dump(ig_metadata.to_hash))
+    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_operation_tests
+      OperationTestGenerator.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
+  end
+end