au_core_test_kit 0.0.16

data/lib/au_core_test_kit/generator/search_test_generator.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+
+module AUCoreTestKit
+  class Generator
+    class SearchTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+                     .reject { |group| SpecialCases.exclude_group? group }
+                     .select { |group| group.searches.present? }
+                     .each do |group|
+            group.searches.each { |search| new(group, search, base_output_dir).generate }
+          end
+        end
+      end
+
+      attr_accessor :group_metadata, :search_metadata, :base_output_dir
+
+      def initialize(group_metadata, search_metadata, base_output_dir)
+        self.group_metadata = group_metadata
+        self.search_metadata = search_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'search.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, profile_identifier)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def test_id
+        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_search_test"
+      end
+
+      def search_identifier
+        search_metadata[:names].join('_').tr('-', '_')
+      end
+
+      def search_title
+        search_identifier.camelize
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}SearchTest"
+      end
+
+      def module_name
+        "AUCore#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def conformance_expectation
+        search_metadata[:expectation]
+      end
+
+      def search_params
+        @search_params ||=
+          search_metadata[:names].map do |name|
+            {
+              name:,
+              path: search_definition(name)[:path]
+            }
+          end
+      end
+
+      def first_search_for_patient_by_patient_id
+        first_search? && resource_type == 'Patient' && search_metadata[:names].first == '_id'
+      end
+
+      def first_search?
+        group_metadata.searches.first == search_metadata
+      end
+
+      def fixed_value_search?
+        first_search? && search_metadata[:names] != ['patient'] &&
+          !group_metadata.delayed? && resource_type != 'Patient'
+      end
+
+      def fixed_value_search_param_name
+        (search_metadata[:names] - [:patient]).first
+      end
+
+      def search_param_name_string
+        search_metadata[:names].join(' + ')
+      end
+
+      def needs_patient_id?
+        search_metadata[:names].include?('patient') ||
+          (resource_type == 'Patient' && search_metadata[:names].include?('_id'))
+      end
+
+      def search_param_names
+        search_params.map { |param| param[:name] }
+      end
+
+      def search_param_names_array
+        array_of_strings(search_param_names)
+      end
+
+      def path_for_value(path)
+        path == 'class' ? 'local_class' : path
+      end
+
+      def required_comparators_for_param(name)
+        search_definition(name)[:comparators].select { |_comparator, expectation| expectation == 'SHALL' }
+      end
+
+      def required_comparators
+        @required_comparators ||=
+          search_param_names.each_with_object({}) do |name, comparators|
+            required_comparators = required_comparators_for_param(name)
+            comparators[name] = required_comparators if required_comparators.present?
+          end
+      end
+
+      def optional?
+        # NOTE: Original behavior changed because we need a clear
+        # expectation of the search parameters in tests. If in the
+        # CapabilityStatement resource we have SHALL it should be
+        # required in the tests.
+        # https://github.com/hl7au/au-fhir-core-inferno/issues/47
+        # conformance_expectation != 'SHALL' || !search_metadata[:must_support_or_mandatory]
+        conformance_expectation != 'SHALL'
+      end
+
+      def search_definition(name)
+        group_metadata.search_definitions[name.to_sym]
+      end
+
+      def saves_delayed_references?
+        first_search? && group_metadata.delayed_references.present?
+      end
+
+      def possible_status_search?
+        search_metadata[:names].none? { |name| name.include? 'status' } &&
+          group_metadata.search_definitions.keys.any? { |key| key.to_s.include? 'status' }
+      end
+
+      def token_search_params
+        @token_search_params ||=
+          search_param_names.select do |name|
+            %w[Identifier CodeableConcept Coding].include? group_metadata.search_definitions[name.to_sym][:type]
+          end
+      end
+
+      def token_search_params_string
+        array_of_strings(token_search_params)
+      end
+
+      def required_multiple_or_search_params
+        @required_multiple_or_search_params ||=
+          search_param_names.select do |name|
+            search_definition(name)[:multiple_or] == 'SHALL'
+          end
+      end
+
+      def optional_multiple_or_search_params
+        @optional_multiple_or_search_params ||=
+          search_param_names.select do |name|
+            search_definition(name)[:multiple_or] == 'SHOULD'
+          end
+      end
+
+      def required_multiple_or_search_params_string
+        array_of_strings(required_multiple_or_search_params)
+      end
+
+      def optional_multiple_or_search_params_string
+        array_of_strings(optional_multiple_or_search_params)
+      end
+
+      def optional_multiple_and_search_params
+        @optional_multiple_and_search_params ||=
+          search_param_names.select do |name|
+            search_definition(name)[:multiple_and] == 'SHOULD'
+          end
+      end
+
+      def required_multiple_and_search_params
+        @required_multiple_and_search_params ||=
+          search_param_names.select do |name|
+            search_definition(name)[:multiple_and] == 'SHALL'
+          end
+      end
+
+      def optional_multiple_and_search_params_string
+        array_of_strings(optional_multiple_and_search_params)
+      end
+
+      def required_multiple_and_search_params_string
+        array_of_strings(required_multiple_and_search_params)
+      end
+
+      def required_comparators_string
+        array_of_strings(required_comparators.keys)
+      end
+
+      def array_of_strings(array)
+        quoted_strings = array.map { |element| "'#{element}'" }
+        "[#{quoted_strings.join(', ')}]"
+      end
+
+      def test_reference_variants?
+        return true if resource_type == 'PractitionerRole' && search_param_names.include?('practitioner')
+
+        first_search? && search_param_names.include?('patient')
+      end
+
+      def test_medication_inclusion?
+        %w[MedicationRequest MedicationDispense].include?(resource_type)
+      end
+
+      def test_post_search?
+        first_search?
+      end
+
+      def includes
+        # The medication SearchParameter does not exist for the MedicationStatement
+        # and MedicationRequest resources in the current version of the IG,
+        # we shall keep special cases to provide functionality for the "_include" tests.
+        # https://jira.csiro.au/browse/ST-400
+        special_cases = {
+          'MedicationRequest:medication' => { 'parameter' => 'MedicationRequest:medication', 'target_resource' => 'Medication', 'paths' => ['medicationReference'] },
+          'MedicationStatement:medication' => { 'parameter' => 'MedicationStatement:medication', 'target_resource' => 'Medication', 'paths' => ['medicationReference'] }
+        }
+        include_params_list = group_metadata.include_params
+        search_definitions = group_metadata.search_definitions
+
+        include_params_list.map do |include_param|
+          if special_cases.key?(include_param)
+            puts "Special case for include_param: #{include_param}"
+
+            return [special_cases[include_param]]
+          end
+
+          target_resource = ''
+          paths = ''
+          search_definitions.each_key do |search_def_key|
+            current_search_def_path = search_definitions[search_def_key]
+            next unless current_search_def_path[:full_paths].first.split('.') == include_param.split(':')
+
+            target_resource = current_search_def_path[:target_resource]
+            paths = current_search_def_path[:paths]
+            break
+          end
+
+          {
+            'parameter' => include_param,
+            'target_resource' => target_resource,
+            'paths' => paths
+          }
+        end
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:first_search] = 'true' if first_search?
+          properties[:fixed_value_search] = 'true' if fixed_value_search?
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names_array
+          properties[:saves_delayed_references] = 'true' if saves_delayed_references?
+          properties[:possible_status_search] = 'true' if possible_status_search?
+          properties[:test_medication_inclusion] = 'true' if test_medication_inclusion?
+          properties[:includes] = includes if group_metadata.include_params.present?
+          properties[:token_search_params] = token_search_params_string if token_search_params.present?
+          properties[:test_reference_variants] = 'true' if test_reference_variants?
+          properties[:params_with_comparators] = required_comparators_string if required_comparators.present?
+          properties[:test_post_search] = 'true' if first_search?
+          properties[:first_search_for_patient_by_patient_id] = 'true' if first_search_for_patient_by_patient_id
+        end
+      end
+
+      def url_version
+        case group_metadata.version
+        when 'v0.3.0-ballot'
+          '0.3.0-ballot'
+        end
+      end
+
+      def search_test_properties_string
+        search_properties
+          .map { |key, value| "#{' ' * 8}#{key}: #{value}" }
+          .join(",\n")
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+
+        group_metadata.add_test(
+          id: test_id,
+          file_name: base_output_file_name
+        )
+      end
+
+      def reference_search_description
+        return '' unless test_reference_variants?
+
+        <<~REFERENCE_SEARCH_DESCRIPTION
+          This test verifies that the server supports searching by reference using
+          the form `#{search_param_names.first}=[id]` as well as `#{search_param_names.first}=#{search_param_names.first.capitalize}/[id]`. The two
+          different forms are expected to return the same number of results. AU
+          Core requires that both forms are supported by AU Core responders.
+        REFERENCE_SEARCH_DESCRIPTION
+      end
+
+      def first_search_description
+        return '' unless first_search?
+
+        <<~FIRST_SEARCH_DESCRIPTION
+          Because this is the first search of the sequence, resources in the
+          response will be used for subsequent tests.
+        FIRST_SEARCH_DESCRIPTION
+      end
+
+      def medication_inclusion_description
+        return '' unless test_medication_inclusion?
+
+        <<~MEDICATION_INCLUSION_DESCRIPTION
+          If any #{resource_type} resources use external references to
+          Medications, the search will be repeated with
+          `_include=#{resource_type}:medication`.
+        MEDICATION_INCLUSION_DESCRIPTION
+      end
+
+      def post_search_description
+        return '' unless test_post_search?
+
+        <<~POST_SEARCH_DESCRIPTION
+          Additionally, this test will check that GET and POST search methods
+          return the same number of results. Search by POST is required by the
+          FHIR R4 specification, and these tests interpret search by GET as a
+          requirement of AU Core #{group_metadata.version}.
+        POST_SEARCH_DESCRIPTION
+      end
+
+      def description
+        <<~DESCRIPTION.gsub(/\n{3,}/, "\n\n")
+          A server #{conformance_expectation} support searching by
+          #{search_param_name_string} on the #{resource_type} resource. This test
+          will pass if resources are returned and match the search criteria. If
+          none are returned, the test is skipped.
+
+          #{medication_inclusion_description}
+          #{reference_search_description}
+          #{first_search_description}
+          #{post_search_description}
+
+          [AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/#{url_version}/CapabilityStatement-au-core-server.html)
+        DESCRIPTION
+      end
+
+      def search_method
+        if search_metadata[:names].first == 'identifier' && group_metadata.name == 'au_core_patient'
+          'run_search_test_with_system'
+        else
+          'run_search_test'
+        end
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/special_cases.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AUCoreTestKit
+  class Generator
+    module SpecialCases
+      RESOURCES_TO_EXCLUDE = %w[
+        Medication
+        RelatedPerson
+      ].freeze
+
+      PROFILES_TO_EXCLUDE = [].freeze
+
+      PATIENT_IDENTIFIERS = [
+        { display: 'IHI', url: 'http://ns.electronichealth.net.au/id/hi/ihi/1.0' },
+        { display: 'Medicare', url: 'http://ns.electronichealth.net.au/id/medicare-number' },
+        { display: 'DVA', url: 'http://ns.electronichealth.net.au/id/dva' }
+      ].freeze
+
+      PRACTITIONER_IDENTIFIERS = [
+        { display: 'HPI-I', url: 'http://ns.electronichealth.net.au/id/hi/hpii/1.0' }
+      ].freeze
+
+      PRACTITIONER_ROLE_IDENTIFIERS = [
+        { display: 'Medicare', url: 'http://ns.electronichealth.net.au/id/medicare-provider-number' }
+      ].freeze
+
+      ORGANIZATION_IDENTIFIERS = [
+        { display: 'HPI-O', url: 'http://ns.electronichealth.net.au/id/hi/hpio/1.0' },
+        { display: 'ABN', url: 'http://hl7.org.au/id/abn' }
+      ].freeze
+
+      # In the current implementation (2024.10.16/1.0.0-ci-build) there is no way
+      # to get information on what search/combo search parameters SHOULD be supported
+      # with the _include parameter. This information exists only in narratives.
+
+      # https://build.fhir.org/ig/hl7au/au-fhir-core/StructureDefinition-au-core-medicationrequest.html#mandatory-search-parameters
+      # https://build.fhir.org/ig/hl7au/au-fhir-core/StructureDefinition-au-core-practitionerrole.html#mandatory-search-parameters
+      # https://github.com/hl7au/au-fhir-core-inferno/issues/199
+
+      SEARCH_PARAMS_FOR_INCLUDE_BY_RESOURCE = {
+        'MedicationRequest' => [
+          ['patient'],
+          %w[patient intent],
+          %w[patient intent status],
+          ['_id'],
+          %w[patient intent authoredon]
+        ],
+        'PractitionerRole' => [
+          ['identifier'],
+          ['practitioner'],
+          ['_id'],
+          ['specialty']
+        ]
+      }.freeze
+
+      MULTIPLE_OR_AND_SEARCH_BY_TARGET_RESOURCE = {
+        'PractitionerRole' => [['practitioner']]
+      }.freeze
+
+      class << self
+        def exclude_group?(group)
+          RESOURCES_TO_EXCLUDE.include?(group.resource)
+        end
+
+        def patient_au_identifiers
+          PATIENT_IDENTIFIERS
+        end
+
+        def practitioner_au_identifiers
+          PRACTITIONER_IDENTIFIERS
+        end
+
+        def practitionerrole_au_identifiers
+          PRACTITIONER_ROLE_IDENTIFIERS
+        end
+
+        def organization_au_identifiers
+          ORGANIZATION_IDENTIFIERS
+        end
+
+        def search_params_for_include_by_resource
+          SEARCH_PARAMS_FOR_INCLUDE_BY_RESOURCE
+        end
+
+        def multiple_or_and_search_by_target_resource
+          MULTIPLE_OR_AND_SEARCH_BY_TARGET_RESOURCE
+        end
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/special_identifier_search_test_generator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+require_relative 'search_test_generator'
+
+module AUCoreTestKit
+  class Generator
+    class SpecialIdentifierSearchTestGenerator < SearchTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups.reject { |group| SpecialCases.exclude_group? group }
+            .select { |group| ['au_core_patient', 'au_core_practitioner', 'au_core_organization', 'au_core_practitionerrole'].include? group.name }
+            .select { |group| group.searches.present? }
+            .each do |group|
+              group.searches.each do |search|
+                next unless search[:names].include? 'identifier'
+                identifier_arr =
+                  case group.name
+                  when 'au_core_patient'
+                    SpecialCases.patient_au_identifiers
+                  when 'au_core_practitioner'
+                    SpecialCases.practitioner_au_identifiers
+                  when 'au_core_practitionerrole'
+                    SpecialCases.practitionerrole_au_identifiers
+                  when 'au_core_organization'
+                    SpecialCases.organization_au_identifiers
+                  end
+                identifier_arr.each do |special_identifier|
+                  new(group, search, base_output_dir, special_identifier).generate
+                end
+              end
+          end
+        end
+      end
+
+      attr_accessor :group_metadata, :search_metadata, :base_output_dir, :special_identifier
+
+      def initialize(group_metadata, search_metadata, base_output_dir, special_identifier)
+        super(group_metadata, search_metadata, base_output_dir)
+        self.special_identifier = special_identifier
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'special_identifier_search.rb.erb'))
+      end
+
+      def test_id
+        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_#{special_identifier[:display].delete('-').downcase}_search_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}#{special_identifier[:display].delete('-')}SearchTest"
+      end
+
+      def optional?
+        true
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names_array
+          properties[:token_search_params] = token_search_params_string if token_search_params.present?
+          properties[:target_identifier] = special_identifier
+        end
+      end
+
+      def title
+        "Server returns valid results for #{resource_type} search by identifier (#{special_identifier[:display]})"
+      end
+
+      def description
+        <<~DESCRIPTION.gsub(/\n{3,}/, "\n\n")
+          A server SHOULD support searching by
+          #{search_param_name_string} (#{special_identifier[:display]}) on the #{resource_type} resource. This test
+          will pass if resources are returned and match the search criteria. If
+          none are returned, the test is skipped.
+
+          [AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/#{url_version}/CapabilityStatement-au-core-server.html)
+        DESCRIPTION
+      end
+    end
+  end
+end

data/lib/au_core_test_kit/generator/special_identifiers_chain_search_test_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'naming'
+require_relative 'special_cases'
+require_relative 'chain_search_test_generator'
+
+module AUCoreTestKit
+  class Generator
+    class SpecialIdentifiersChainSearchTestGenerator < ChainSearchTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+                     .select { |group| group.searches.present? }
+                     .each do |group|
+            group.search_definitions.each_key do |search_key|
+              current_search_definition = group.search_definitions[search_key]
+              next unless current_search_definition.key?(:chain) && current_search_definition[:chain].length.positive?
+
+              current_search_definition[:chain].each do |chain_item|
+                next unless chain_item[:target] == 'Patient'
+
+                SpecialCases.patient_au_identifiers.each do |target_identifier|
+                  new(
+                    search_key.to_s,
+                    group,
+                    group.search_definitions[search_key],
+                    base_output_dir,
+                    chain_item,
+                    target_identifier
+                  ).generate
+                end
+              end
+            end
+          end
+        end
+      end
+
+      attr_accessor :search_name, :group_metadata, :search_metadata, :base_output_dir, :chain_item, :target_identifier
+
+      def initialize(search_name, group_metadata, search_metadata, base_output_dir, chain_item, target_identifier)
+        super(search_name, group_metadata, search_metadata, base_output_dir, chain_item)
+        self.target_identifier = target_identifier
+      end
+
+      def test_id
+        "au_core_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_#{target_identifier[:display].downcase}_chain_search_test"
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}_#{target_identifier[:display]}_ChainSearchTest"
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names_array
+          properties[:attr_paths] = attribute_paths
+          properties[:target_identifier] = target_identifier
+        end
+      end
+
+      def title
+        "Server returns valid results for #{resource_type} search by #{search_param_name_string} (#{target_identifier[:display]}) (chained parameters)"
+      end
+
+      def description
+        <<~DESCRIPTION.gsub(/\n{3,}/, "\n\n")
+          A server #{conformance_expectation} support searching by
+          #{search_param_names.first} (#{target_identifier[:display]}) on the #{resource_type} resource. This test
+          will pass if the server returns a success response to the request.
+
+          [AU Core Server CapabilityStatement](http://hl7.org.au/fhir/core/#{url_version}/CapabilityStatement-au-core-server.html)
+        DESCRIPTION
+      end
+    end
+  end
+end