inferno_core 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 404dc10cd08aff285dbac620bdcf7330938e1f97ae2933e3c87dc399a2551551
-  data.tar.gz: 1fed11cfea855b9b3543f01e19053cea9bd98dd589d18abe3310b13f7d519172
+  metadata.gz: 7c009d9329c63f4c737ce53c79d6b88af8db643550d2509784b6e3a43558d237
+  data.tar.gz: 5e0e2e2d7e861b38caa73ab2f6d83fc6a45a29a2e33744f67b8853df7766a5b1
 SHA512:
-  metadata.gz: 9160481ca996a9ce316e8192c57bd72c15ff51a3eaff09fddec90283fbfd2ec8e1959fed8636744f79531ffffffbdf6addd0da165a24eed2bc741394c3285ae3
-  data.tar.gz: 455f609148df1220216d6dba1862d8361719372d4a26e46a8303e864ab4041cfa9da3ac726cb6909aac204679b31a1c28f5d5a1d2c8a1fb5f1fcf77c7631c0ac
+  metadata.gz: f47f2704474b9f7eea33679463bd284a91ef02466949f317ade4378b08c602a8f89646dc5914972002d707c3391d24e8b9b5332cc79b946bc2a975f6b0ca3693
+  data.tar.gz: 420d52d34c90f103375ed615a8d2e8d01b7cdfe1eac220b41c9458dcc33aa9ed2aafa54a8e0403966987b652e07f5e510f95f93caeaa79be6197ebf4dbe58d0e

data/lib/inferno/apps/cli/evaluate.rb

@@ -8,12 +8,9 @@ require 'tempfile'
 module Inferno
   module CLI
     class Evaluate < Thor::Group
-      include Thor::Actions
-      include Inferno::Utils::IgDownloader
-
       def evaluate(ig_path, data_path, _log_level)
         validate_args(ig_path, data_path)
-        ig = get_ig(ig_path)
+        ig = Inferno::Repositories::IGs.new.find_or_load(ig_path)
 
         check_ig_version(ig)
 
@@ -39,24 +36,6 @@ module Inferno
         raise "Provided path '#{data_path}' is not a directory"
       end
 
-      def get_ig(ig_path)
-        if File.exist?(ig_path)
-          ig = Inferno::Entities::IG.from_file(ig_path)
-        elsif in_user_package_cache?(ig_path.sub('@', '#'))
-          # NPM syntax for a package identifier is id@version (eg, hl7.fhir.us.core@3.1.1)
-          # but in the cache the separator is # (hl7.fhir.us.core#3.1.1)
-          cache_directory = File.join(user_package_cache, ig_path.sub('@', '#'))
-          ig = Inferno::Entities::IG.from_file(cache_directory)
-        else
-          Tempfile.create(['package', '.tgz']) do |temp_file|
-            load_ig(ig_path, nil, { force: true }, temp_file.path)
-            ig = Inferno::Entities::IG.from_file(temp_file.path)
-          end
-        end
-        ig.add_self_to_repository
-        ig
-      end
-
       def check_ig_version(ig)
         versions = ig.ig_resource.fhirVersion
 
@@ -65,14 +44,6 @@ module Inferno
         puts '**WARNING** The selected IG targets a FHIR version higher than 4.0.1, which is not supported by Inferno.'
       end
 
-      def user_package_cache
-        File.join(Dir.home, '.fhir', 'packages')
-      end
-
-      def in_user_package_cache?(ig_identifier)
-        File.directory?(File.join(user_package_cache, ig_identifier))
-      end
-
       def output_results(results, output)
         if output&.end_with?('json')
           oo = FhirEvaluator::EvaluationResult.to_operation_outcome(results)

data/lib/inferno/apps/cli/new.rb

@@ -112,9 +112,8 @@ module Inferno
       end
 
       def load_igs
-        config = { verbose: !options['quiet'] }
         options['implementation_guide']&.each_with_index do |ig, idx|
-          uri = options['implementation_guide'].length == 1 ? load_ig(ig, nil, config) : load_ig(ig, idx, config)
+          uri = options['implementation_guide'].length == 1 ? load_ig(ig, nil) : load_ig(ig, idx)
           say_unless_quiet "Downloaded IG from #{uri}"
         rescue OpenURI::HTTPError => e
           say_unless_quiet "Failed to install implementation guide #{ig}", :red

data/lib/inferno/apps/cli/templates/.env.development

@@ -1,3 +1,4 @@
 FHIR_RESOURCE_VALIDATOR_URL=http://localhost/hl7validatorapi
 REDIS_URL=redis://localhost:6379/0
 FHIRPATH_URL=http://localhost/fhirpath
+INFERNO_HOST=http://localhost:4567

data/lib/inferno/apps/cli/templates/.env.production

@@ -1,3 +1,4 @@
 REDIS_URL=redis://redis:6379/0
 FHIR_RESOURCE_VALIDATOR_URL=http://hl7_validator_service:3500
 FHIRPATH_URL=http://fhirpath:6789
+INFERNO_HOST=http://localhost

data/lib/inferno/apps/cli/templates/.gitignore

@@ -1,4 +1,5 @@
 /data/*.db
+/data/igs/*.tgz
 /data/redis/**/*.rdb
 /data/redis/**/*.aof
 /data/redis/**/*.manifest

data/lib/inferno/apps/cli/templates/docker-compose.background.yml.tt

@@ -7,7 +7,7 @@ services:
       # Negative values mean sessions never expire, 0 means sessions immediately expire
       SESSION_CACHE_DURATION: -1
     volumes:
-      - ./<%= ig_path %>:/app/igs
+      - ./data/igs:/app/igs
       # To let the service share your local FHIR package cache,
       # uncomment the below line
       # - ~/.fhir:/home/ktor/.fhir
@@ -15,7 +15,7 @@ services:
     image: infernocommunity/fhir-validator-service
     # Update this path to match your directory structure
     volumes:
-      - ./<%= ig_path %>:/home/igs
+      - ./data/igs:/home/igs
   fhir_validator_app:
     image: infernocommunity/fhir-validator-app
     depends_on:

data/lib/inferno/apps/web/controllers/controller.rb

@@ -20,7 +20,9 @@ module Inferno
           # Hanami Controller 2.0.0 removes the ability to set a default
           # Content-Type response header, so set it manually if it hasn't been
           # set.
-          subclass.after { |_req, res| res.format = :json if res.format == :all && res.body&.first&.first == '{' }
+          subclass.after do |_req, res|
+            res.format = :json if res.format == :all
+          end
         end
 
         def self.resource_name

data/lib/inferno/apps/web/router.rb

@@ -4,8 +4,12 @@ Dir.glob(File.join(__dir__, 'controllers', '**', '*.rb')).each { |path| require_
 
 module Inferno
   module Web
-    client_page = ERB.new(File.read(File.join(Inferno::Application.root, 'lib', 'inferno', 'apps', 'web',
-                                              'index.html.erb'))).result
+    client_page = ERB.new(
+      File.read(
+        File.join(Inferno::Application.root, 'lib', 'inferno', 'apps', 'web', 'index.html.erb')
+      )
+    ).result
+    CLIENT_PAGE_RESPONSE = ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
 
     base_path = Application['base_path']&.delete_prefix('/')
 
@@ -47,12 +51,14 @@ module Inferno
 
         get '/requests/:id', to: Inferno::Web::Controllers::Requests::Show, as: :requests_show
 
-        get '/version', to: ->(_env) { [200, {}, [{ 'version' => Inferno::VERSION.to_s }.to_json]] }, as: :version
+        get '/version', to: lambda { |_env|
+          [200, { 'Content-Type' => 'application/json' }, [{ 'version' => Inferno::VERSION.to_s }.to_json]]
+        }, as: :version
       end
 
       # Should not need Content-Type header but GitHub Codespaces will not work without them.
       # This could be investigated and likely removed if addressed properly elsewhere.
-      get '/', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
+      get '/', to: CLIENT_PAGE_RESPONSE
       get '/jwks.json', to: lambda { |_env|
                               [200, { 'Content-Type' => 'application/json' }, [Inferno::JWKS.jwks_json]]
                             }, as: :jwks
@@ -70,7 +76,7 @@ module Inferno
 
       Inferno::Repositories::TestSuites.all.map { |suite| "/#{suite.id}" }.each do |suite_path|
         Application['logger'].info("Registering suite route: #{suite_path}")
-        get suite_path, to: ->(_env) { [200, {}, [client_page]] }
+        get suite_path, to: CLIENT_PAGE_RESPONSE
       end
 
       get '/test_sessions/:id', to: Inferno::Web::Controllers::TestSessions::ClientShow, as: :client_session_show
@@ -83,7 +89,7 @@ module Inferno
       if base_path.present?
         Hanami::Router.new do
           scope("#{base_path}/") do
-            get '/', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
+            get '/', to: CLIENT_PAGE_RESPONSE
           end
           scope(base_path, &route_block)
         end

data/lib/inferno/config/boot/ig_files.rb

@@ -0,0 +1,47 @@
+require 'fileutils'
+
+Inferno::Application.register_provider(:ig_files) do
+  prepare do
+    # This process should only run once, so skipping it on workers will start it
+    # only once from the "web" process
+    next if Sidekiq.server?
+
+    target_container.start :logging
+
+    test_kit_gems = Bundler.definition.specs.select { |spec| spec.metadata['inferno_test_kit']&.casecmp? 'true' }
+
+    test_kit_ig_files = test_kit_gems.map do |test_kit|
+      files = Dir.glob(File.join(test_kit.full_gem_path, 'lib', '*', 'igs', '*.tgz'))
+      next if files.blank?
+
+      {
+        test_kit_name: test_kit.name,
+        files:
+      }
+    end.compact
+
+    local_ig_files = Dir.glob(File.join(Dir.pwd, 'lib', '*', 'igs', '*.tgz'))
+
+    if local_ig_files.present? && test_kit_gems.none? { |gem| gem.full_gem_path == Dir.pwd }
+      test_kit_ig_files += {
+        test_kit_name: 'current project',
+        files: local_ig_files
+      }
+    end
+
+    igs_directory = File.join(Dir.pwd, 'data', 'igs')
+    if File.exist? igs_directory
+      FileUtils.rm_f(Dir.glob(File.join(igs_directory, '*.tgz')))
+
+      test_kit_ig_files.each do |ig_files|
+        ig_files[:files].each do |source_file_path|
+          destination_file_path = File.join(igs_directory, File.basename(source_file_path))
+          Inferno::Application['logger'].info(
+            "Copying #{File.basename(source_file_path)} to data/igs from #{ig_files[:test_kit_name]}"
+          )
+          FileUtils.copy_file(source_file_path, destination_file_path, true)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/config/boot/validator.rb

@@ -1,6 +1,7 @@
 Inferno::Application.register_provider(:validator) do
   prepare do
     target_container.start :suites
+    target_container.start :ig_files
 
     # This process should only run once, to start one job per validator,
     # so skipping it on workers will start it only once from the "web" process

data/lib/inferno/config/boot/web.rb

@@ -1,14 +1,18 @@
 Inferno::Application.register_provider(:web) do |_app|
   prepare do
     require 'blueprinter'
-    require 'hanami/router'
-    require 'hanami/controller'
     require 'oj'
 
     Blueprinter.configure do |config|
       config.generator = Oj
     end
 
+    # Workers aren't connected to a web server, so they shouldn't be hosting
+    # routes
+    next if Sidekiq.server?
+
+    require 'hanami/router'
+    require 'hanami/controller'
     require 'inferno/utils/middleware/request_logger'
     require 'inferno/apps/web/application'
   end

data/lib/inferno/dsl/assertions.rb

@@ -197,6 +197,32 @@ module Inferno
       def bad_content_type_message(expected, received)
         "Expected `Content-Type` to be `#{expected}`, but found `#{received}`"
       end
+
+      # Check that all Must Support elements defined on the given profile are present in the given resources.
+      # Must Support elements are identified on the profile StructureDefinition and pre-parsed into metadata,
+      # which may be customized prior to the check by passing a block. Alternate metadata may be provided directly.
+      # Set test suite config flag debug_must_support_metadata: true to log the metadata to a file for debugging.
+      #
+      # @param resources [Array<FHIR::Resource>]
+      # @param profile_url [String]
+      # @param validator_name [Symbol] Name of the FHIR Validator that references the IG the profile is in
+      # @param metadata [Hash] MustSupport Metadata (optional),
+      #        if provided the check will use this instead of re-generating metadata from the profile
+      # @param requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
+      # @yield [Metadata] Customize the metadata before running the test
+      # @return [void]
+      def assert_must_support_elements_present(resources, profile_url, validator_name: :default, metadata: nil,
+                                               requirement_extension: nil, &)
+        missing_elements = missing_must_support_elements(resources, profile_url, validator_name:, metadata:,
+                                                                                 requirement_extension:, &)
+        assert missing_elements.empty?, missing_must_support_elements_message(missing_elements, resources)
+      end
+
+      # @private
+      def missing_must_support_elements_message(missing_elements, resources)
+        "Could not find #{missing_elements.join(', ')} in the #{resources.length} " \
+          'provided resource(s)'
+      end
     end
   end
 end

data/lib/inferno/dsl/fhir_client_builder.rb

@@ -43,6 +43,7 @@ module Inferno
         instance_exec(self, &block)
 
         FHIR::Client.new(url).tap do |client|
+          client.use_accept_charset = false
           client.additional_headers = headers if headers
           client.default_json
           client.set_bearer_token bearer_token if bearer_token

data/lib/inferno/dsl/fhir_evaluation/rules/all_must_supports_present.rb

@@ -1,6 +1,7 @@
 require_relative '../../fhir_resource_navigation'
 require_relative '../../must_support_metadata_extractor'
 require_relative '../profile_conformance_helper'
+require_relative '../../must_support_assessment'
 
 module Inferno
   module DSL
@@ -16,7 +17,9 @@ module Inferno
         class AllMustSupportsPresent < Rule
           include FHIRResourceNavigation
           include ProfileConformanceHelper
-          attr_accessor :metadata
+          include MustSupportAssessment
+
+          attr_accessor :metadata, :ig
 
           # check is invoked from the evaluator CLI and applies the logic for this Rule to the provided data.
           # At least one instance of every MustSupport element defined in the profiles must be populated in the data.
@@ -26,7 +29,8 @@ module Inferno
           # @return [void]
           def check(context)
             missing_items_by_profile = {}
-            context.ig.profiles.each do |profile|
+            ig = context.ig
+            ig.profiles.each do |profile|
               resources = pick_resources_for_profile(profile, context)
               if resources.blank?
                 missing_items_by_profile[profile.url] = ['No matching resources were found to check']
@@ -34,9 +38,8 @@ module Inferno
               end
               requirement_extension = context.config.data['Rule']['AllMustSupportsPresent']['RequirementExtensionUrl']
               debug_metadata = context.config.data['Rule']['AllMustSupportsPresent']['WriteMetadataForDebugging']
-              profile_metadata = extract_metadata(profile, context.ig, requirement_extension:)
-              missing_items = perform_must_support_test_with_metadata(resources, profile_metadata, debug_metadata:)
-
+              missing_items = perform_must_support_assessment(profile, resources, ig, debug_metadata:,
+                                                                                      requirement_extension:)
               missing_items_by_profile[profile.url] = missing_items if missing_items.any?
             end
 
@@ -68,309 +71,11 @@ module Inferno
             end
           end
 
-          # perform_must_support_test is invoked from DSL assertions, allows customizing the metadata with a block.
-          # Customizing the metadata may add, modify, or remove items.
-          # For instance, US Core 3.1.1 Patient "Previous Name" is defined as MS only in narrative.
-          # Choices are also defined only in narrative.
-          # @param profile [FHIR::StructureDefinition]
-          # @param resources [Array<FHIR::Model>]
-          # @param ig [Inferno::Entities::IG]
-          # @param debug_metadata [Boolean] if true, write out the final metadata used to a temporary file
-          # @param requirement_extension [String] Extension URL that implies "required" as an alternative to the MS flag
-          # @yield [Metadata] Customize the metadata before running the test
-          # @return [Array<String>] list of elements that were not found in the provided resources
-          def perform_must_support_test(profile, resources, ig, debug_metadata: false, requirement_extension: nil)
-            profile_metadata = extract_metadata(profile, ig, requirement_extension:)
-            yield profile_metadata if block_given?
-
-            perform_must_support_test_with_metadata(resources, profile_metadata, debug_metadata:)
-          end
-
-          # perform_must_support_test_with_metadata is invoked from check and perform_must_support_test,
-          # with the metadata to be used as the basis for the test.
-          # It may also be invoked directly from a test if you want to completely overwrite the metadata.
-          # @param resources [Array<FHIR::Model>]
-          # @param profile_metadata [Metadata] Metadata object with must_supports field
-          # @param debug_metadata [Boolean] if true, write out the final metadata used to a temporary file
-          # @return [Array<String>] list of elements that were not found in the provided resources
-          def perform_must_support_test_with_metadata(resources, profile_metadata, debug_metadata: false)
-            return if resources.blank?
-
-            @metadata = profile_metadata
-
-            write_metadata_for_debugging if debug_metadata
-
-            missing_elements(resources)
-            missing_slices(resources)
-            missing_extensions(resources)
-
-            handle_must_support_choices if metadata.must_supports[:choices].present?
-
-            missing_must_support_strings
-          end
-
-          def extract_metadata(profile, ig, requirement_extension: nil)
-            MustSupportMetadataExtractor.new(profile.snapshot.element, profile, profile.type, ig, requirement_extension)
-          end
-
-          def write_metadata_for_debugging
-            outfile = "#{metadata.profile&.id}-#{SecureRandom.uuid}.yml"
-
-            File.open(File.join(Dir.tmpdir, outfile), 'w') do |f|
-              writable_metadata = { must_supports: @metadata.must_supports.to_hash }
-              f.write(YAML.dump(writable_metadata))
-              puts "Wrote MustSupport metadata to #{f.path}"
-            end
-          end
-
-          def handle_must_support_choices
-            handle_must_support_element_choices
-            handle_must_support_extension_choices
-            handle_must_support_slice_choices
-          end
-
-          def handle_must_support_element_choices
-            missing_elements.delete_if do |element|
-              choices = metadata.must_supports[:choices].find do |choice|
-                choice[:paths]&.include?(element[:path]) ||
-                  choice[:elements]&.any? { |ms_element| ms_element[:path] == element[:path] }
-              end
-              any_choice_supported?(choices)
-            end
-          end
-
-          def handle_must_support_extension_choices
-            missing_extensions.delete_if do |extension|
-              choices = metadata.must_supports[:choices].find do |choice|
-                choice[:extension_ids]&.include?(extension[:id])
-              end
-              any_choice_supported?(choices)
-            end
-          end
-
-          def handle_must_support_slice_choices
-            missing_slices.delete_if do |slice|
-              choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
-              any_choice_supported?(choices)
-            end
-          end
-
-          def any_choice_supported?(choices)
-            return false unless choices.present?
-
-            any_path_choice_supported?(choices) ||
-              any_extension_ids_choice_supported?(choices) ||
-              any_slice_names_choice_supported?(choices) ||
-              any_elements_choice_supported?(choices)
-          end
-
-          def any_path_choice_supported?(choices)
-            return false unless choices[:paths].present?
-
-            choices[:paths].any? { |path| missing_elements.none? { |element| element[:path] == path } }
-          end
-
-          def any_extension_ids_choice_supported?(choices)
-            return false unless choices[:extension_ids].present?
-
-            choices[:extension_ids].any? do |extension_id|
-              missing_extensions.none? { |extension| extension[:id] == extension_id }
-            end
-          end
-
-          def any_slice_names_choice_supported?(choices)
-            return false unless choices[:slice_names].present?
-
-            choices[:slice_names].any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name } }
-          end
-
-          def any_elements_choice_supported?(choices)
-            return false unless choices[:elements].present?
-
-            choices[:elements].any? do |choice|
-              missing_elements.none? do |element|
-                element[:path] == choice[:path] && element[:fixed_value] == choice[:fixed_value]
-              end
-            end
-          end
-
-          def missing_must_support_strings
-            missing_elements.map { |element_definition| missing_element_string(element_definition) } +
-              missing_slices.map { |slice_definition| slice_definition[:slice_id] } +
-              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 must_support_extensions
-            metadata.must_supports[:extensions]
-          end
-
-          def missing_extensions(resources = [])
-            @missing_extensions ||=
-              must_support_extensions.select do |extension_definition|
-                resources.none? do |resource|
-                  path = extension_definition[:path]
-
-                  if path == 'extension'
-                    resource.extension.any? { |extension| extension.url == extension_definition[:url] }
-                  else
-                    extension = find_a_value_at(resource, path) do |el|
-                      el.url == extension_definition[:url]
-                    end
-
-                    extension.present?
-                  end
-                end
-              end
-          end
-
-          def must_support_elements
-            metadata.must_supports[:elements]
-          end
-
-          def missing_elements(resources = [])
-            @missing_elements ||= find_missing_elements(resources, must_support_elements)
-          end
-
-          def find_missing_elements(resources, must_support_elements)
-            must_support_elements.select do |element_definition|
-              resources.none? { |resource| resource_populates_element?(resource, element_definition) }
-            end
-          end
-
-          def resource_populates_element?(resource, element_definition)
-            path = element_definition[:path]
-            ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{path}.extension" }
-              .map { |ex| ex[:url] }
-
-            value_found = find_a_value_at(resource, path) do |potential_value|
-              matching_without_extensions?(potential_value, ms_extension_urls, 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
-
-          def matching_without_extensions?(value, ms_extension_urls, fixed_value)
-            if value.instance_of?(Inferno::DSL::PrimitiveType)
-              urls = value.extension&.map(&:url)
-              has_ms_extension = (urls & ms_extension_urls).present?
-              value = value.value
-            end
-
-            return false unless has_ms_extension || value_without_extensions?(value)
-
-            matches_fixed_value?(value, fixed_value)
-          end
-
-          def matches_fixed_value?(value, fixed_value)
-            fixed_value.blank? || value == fixed_value
-          end
-
-          def value_without_extensions?(value)
-            value_without_extensions = value.respond_to?(:to_hash) ? value.to_hash.except('extension') : value
-            value_without_extensions.present? || value_without_extensions == false
-          end
-
-          def must_support_slices
-            metadata.must_supports[:slices]
-          end
-
-          def missing_slices(resources = [])
-            @missing_slices ||=
-              must_support_slices.select do |slice|
-                resources.none? do |resource|
-                  path = slice[:path]
-                  find_slice(resource, path, slice[:discriminator]).present?
-                end
-              end
-          end
-
-          def find_slice(resource, path, discriminator)
-            # TODO: there is a lot of similarity
-            # between this and FHIRResourceNavigation.matching_slice?
-            # Can these be combined?
-            find_a_value_at(resource, path) do |element|
-              case discriminator[:type]
-              when 'patternCodeableConcept'
-                find_pattern_codeable_concept_slice(element, discriminator)
-              when 'patternCoding'
-                find_pattern_coding_slice(element, discriminator)
-              when 'patternIdentifier'
-                find_pattern_identifier_slice(element, discriminator)
-              when 'value'
-                find_value_slice(element, discriminator)
-              when 'type'
-                find_type_slice(element, discriminator)
-              when 'requiredBinding'
-                find_required_binding_slice(element, discriminator)
-              end
-            end
-          end
-
-          def find_pattern_codeable_concept_slice(element, discriminator)
-            coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
-            find_a_value_at(element, coding_path) do |coding|
-              coding.code == discriminator[:code] && coding.system == discriminator[:system]
-            end
-          end
-
-          def find_pattern_coding_slice(element, discriminator)
-            coding_path = discriminator[:path].present? ? discriminator[:path] : ''
-            find_a_value_at(element, coding_path) do |coding|
-              coding.code == discriminator[:code] && coding.system == discriminator[:system]
-            end
-          end
-
-          def find_pattern_identifier_slice(element, discriminator)
-            find_a_value_at(element, discriminator[:path]) do |identifier|
-              identifier.system == discriminator[:system]
-            end
-          end
-
-          def find_value_slice(element, discriminator)
-            values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
-            find_slice_by_values(element, values)
-          end
-
-          def find_type_slice(element, discriminator)
-            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
-          end
-
-          def find_required_binding_slice(element, discriminator)
-            coding_path = discriminator[:path].present? ? "#{discriminator[:path]}.coding" : 'coding'
-
-            find_a_value_at(element, coding_path) do |coding|
-              discriminator[:values].any? { |value| value[:system] == coding.system && value[:code] == coding.code }
-            end
-          end
-
-          def find_slice_by_values(element, value_definitions)
-            Array.wrap(element).find { |el| verify_slice_by_values(el, value_definitions) }
+          # @private
+          def find_ig_and_profile(profile_url, _validator_name)
+            # Normally this would be done by a Test's validator,
+            # but here we're outside the context of a Test.
+            [ig, ig.profile_by_url(profile_url)]
           end
         end
       end