au_core_test_kit 0.0.16

data/lib/au_core_test_kit/generator/group_metadata.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  class Generator
+    class GroupMetadata
+      ATTRIBUTES = %i[
+        name
+        class_name
+        version
+        reformatted_version
+        resource
+        profile_url
+        profile_name
+        profile_version
+        title
+        short_description
+        interactions
+        operations
+        searches
+        search_definitions
+        include_params
+        revincludes
+        required_concepts
+        must_supports
+        mandatory_elements
+        bindings
+        references
+        tests
+        id
+        file_name
+        delayed_references
+      ].freeze
+
+      NON_USCDI_RESOURCES = {
+        'Encounter' => %w[v311 v400],
+        'Location' => %w[v311 v400 v501 v610],
+        'Organization' => %w[v311 v400 v501 v610],
+        'Practitioner' => %w[v311 v400 v501 v610],
+        'PractitionerRole' => %w[v311 v400 v501 v610],
+        'Provenance' => %w[v311 v400 v501 v610],
+        'RelatedPerson' => %w[v501 v610],
+        'Specimen' => ['v610']
+      }.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?
+        return false if resource == 'Patient'
+
+        no_patient_searches? || non_uscdi_resource?
+      end
+
+      def no_patient_searches?
+        searches.none? { |search| search[:names].include? 'patient' }
+      end
+
+      def non_uscdi_resource?
+        NON_USCDI_RESOURCES.key?(resource) && NON_USCDI_RESOURCES[resource].include?(reformatted_version)
+      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/au_core_test_kit/generator/group_metadata_extractor.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+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 AUCoreTestKit
+  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:,
+            # test_id_prefix: test_id_prefix,
+            resource:,
+            profile_url:,
+            profile_name:,
+            profile_version:,
+            title:,
+            short_description:,
+            interactions:,
+            operations:,
+            searches:,
+            search_definitions:,
+            include_params:,
+            revincludes:,
+            required_concepts:,
+            must_supports:,
+            mandatory_elements:,
+            bindings:,
+            references:
+            # tests: []
+          }
+
+        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]
+            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_mandatory_elements = mandatory_elements.any? do |element|
+              full_paths.include?(element)
+            end
+
+            any_must_support_elements || any_must_support_slices || any_mandatory_elements
+          end
+
+          search[:must_support_or_mandatory] = search[:names_not_must_support_or_mandatory].empty?
+        end
+      end
+
+      ### BEGIN SPECIAL CASES ###
+
+      ALL_VERSION_CATEGORY_FIRST_PROFILES = [
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-diagnosticresult-path',
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-diagnosticresult-imag'
+      ].freeze
+
+      ALL_VERSION_PATIENT_FIRST_PROFILES = [
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-observation',
+      ].freeze
+
+      ALL_VERSION_ID_FIRST_PROFILES = [
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-organization',
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-practitioner'
+      ].freeze
+
+      ALL_VERSION_NAME_FIRST_PROFILES = [
+        'http://hl7.org.au/fhir/core/StructureDefinition/au-core-healthcareservice'
+      ].freeze
+
+      # Usage example
+      VERSION_SPECIFIC_CATEGORY_FIRST_PROFILES = {
+        # 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-healthcareservice' => ['v030']
+      }.freeze
+
+      def name_first_profile?
+        ALL_VERSION_NAME_FIRST_PROFILES.include? profile_url
+      end
+
+      def id_first_profile?
+        ALL_VERSION_ID_FIRST_PROFILES.include? profile_url
+      end
+
+      def category_first_profile?
+        ALL_VERSION_CATEGORY_FIRST_PROFILES.include?(profile_url) ||
+          VERSION_SPECIFIC_CATEGORY_FIRST_PROFILES[profile_url]&.include?(reformatted_version)
+      end
+
+      def patient_first_profile?
+        ALL_VERSION_PATIENT_FIRST_PROFILES.include?(profile_url)
+      end
+
+      def first_search_params
+        @first_search_params ||=
+          if category_first_profile?
+            %w[patient category]
+          elsif patient_first_profile?
+            ['patient']
+          elsif id_first_profile?
+            ['_id']
+          elsif name_first_profile?
+            ['name']
+          elsif resource == 'Observation'
+            %w[patient code]
+          elsif resource == 'MedicationRequest'
+            ['patient']
+          elsif resource == 'CareTeam'
+            %w[patient status]
+          else
+            ['patient']
+          end
+      end
+
+      def handle_special_cases
+        set_first_search
+      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
+
+      ### END SPECIAL CASES ###
+
+      def profile
+        # It's a temporary solution. Discuss it with the team
+        new_profile_url = profile_url == 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-relatedperson' ? 'http://hl7.org.au/fhir/StructureDefinition/au-relatedperson' : profile_url
+        @profile ||= ig_resources.profile_by_url(new_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('AUCore', "AUCore#{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
+        profile.title.gsub('  ', ' ')
+      end
+
+      def profile_version
+        profile.version
+      end
+
+      def title
+        title = profile.title.gsub(/AU\s*Core\s*/, '').gsub(/\s*Profile/, '').strip
+
+        title = "#{resource} #{title.split(resource).map(&:strip).join(' ')}" if Naming.resources_with_multiple_profiles.include?(resource) && !title.start_with?(resource) && version != 'v3.1.1'
+
+        title
+      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,
+          profile_elements,
+          {
+            resource:,
+            profile_url:,
+            must_supports:
+          }
+        )
+      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 required_concepts
+        # The base FHIR vital signs profile has a required binding that isn't
+        # relevant for any of its child profiles
+        return [] if resource == 'Observation'
+
+        profile_elements
+          .select { |element| element.type&.any? { |type| type.code == 'CodeableConcept' } }
+          .select { |element| element.binding&.strength == 'required' }
+          .map { |element| element.path.gsub("#{resource}.", '').gsub('[x]', 'CodeableConcept') }
+          .uniq
+      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? }
+          .map(&:path)
+          .uniq
+      end
+
+      def references
+        @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
+    end
+  end
+end

data/lib/au_core_test_kit/generator/ig_download.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'json'
+require 'net/http'
+
+url = 'http://hl7.org.au/fhir/core/history.html'
+
+begin
+  uri = URI.parse(url)
+  response = Net::HTTP.get_response(uri)
+
+  unless response.is_a?(Net::HTTPSuccess)
+    puts "Failed to fetch HTML content from #{url}. HTTP Status: #{response.code} #{response.message}"
+    exit
+  end
+
+  html_content = response.body
+
+  doc = Nokogiri::HTML(html_content)
+
+  script_tag = doc.at('script:contains("var pageJSON")')
+
+  ig_versions_to_skip = ['0.1.0-draft', '0.2.0-preview', '0.2.1-preview', '0.2.2-preview', '0.3.0-ballot', '0.4.1-preview', '1.0.0-ballot', 'current']
+
+  if script_tag&.content
+    json_data = script_tag.content[/\{.*\}/m]
+    if json_data
+      data_hash = JSON.parse(json_data)
+      data_hash['list'].each do |item|
+        version = item['version']
+        next if ig_versions_to_skip.include? version
+
+        package_url = "#{item['path']}/package.tgz"
+        file_name = "#{version}.tgz"
+        output_directory = 'lib/au_core_test_kit/igs'
+
+        Dir.mkdir(output_directory) unless File.directory?(output_directory)
+
+        File.open(File.join(output_directory, file_name), 'wb') do |file|
+          uri = URI.parse(package_url)
+          response = Net::HTTP.get_response(uri)
+          if response.is_a?(Net::HTTPSuccess)
+            file.write(response.body)
+            puts "Successfully downloaded #{file_name}"
+          else
+            puts "Failed to download #{file_name}. HTTP Status: #{response.code} #{response.message}"
+          end
+        end
+      end
+    else
+      puts 'Error: Unable to extract JSON data from script tag.'
+    end
+  else
+    puts 'Error: Script tag containing pageJSON variable not found.'
+  end
+rescue StandardError => e
+  puts "An error occurred: #{e.message}"
+end

data/lib/au_core_test_kit/generator/ig_loader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'fhir_models'
+require 'pathname'
+require 'rubygems/package'
+require 'zlib'
+require 'json'
+require_relative 'ig_resources'
+
+module AUCoreTestKit
+  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 if file_name.end_with? 'openapi.json'
+
+          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
+        json_files = Dir.glob(File.join(Dir.pwd, 'lib', 'au_core_test_kit', 'igs', '*.json'))
+        json_files.each do |file_path|
+          file_content = File.read(file_path)
+          bundle = FHIR.from_contents(file_content)
+          bundle.entry.each do |entry|
+            ig_resources.add(entry.resource)
+          end
+        end
+        ig_resources
+      end
+
+      def load_standalone_resources
+        ig_directory = ig_file_name.chomp('.tgz')
+
+        return ig_resources unless File.exist? ig_directory
+
+        Dir.glob(File.join(ig_directory, '*.json')).each do |file_path|
+          begin
+            resource = FHIR.from_contents(File.read(file_path))
+            next if resource.nil?
+          rescue StandardError
+            file_name = file_path.split('/').last
+            puts "#{file_name} does not appear to be a FHIR resource."
+            next
+          end
+
+          ig_resources.add(resource)
+        end
+
+        ig_resources
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/ig_metadata.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  class Generator
+    class IGMetadata
+      attr_accessor :ig_version, :groups
+
+      def reformatted_version
+        @reformatted_version ||= ig_version.delete('.').gsub('-', '_')
+      end
+
+      def ordered_groups
+        @ordered_groups ||=
+          [patient_group] + non_delayed_groups + delayed_groups
+      end
+
+      def patient_group
+        @patient_group ||=
+          groups.find { |group| group.resource == 'Patient' }
+      end
+
+      def delayed_groups
+        @delayed_groups ||=
+          groups.select(&:delayed?)
+      end
+
+      def non_delayed_groups
+        @non_delayed_groups ||=
+          groups.reject(&:delayed?) - [patient_group]
+      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