improve must support assessment by normalizing extension URLs and correctly handling discriminator paths for Bundle entries.

Author: abhinandan2012

lib/inferno/dsl/fhir_resource_navigation.rb

@@ -194,7 +194,6 @@ def matching_type_slice?(slice, discriminator)
         when 'String'
           slice_value.is_a? String
         else
-          slice_value = slice_value.resource if slice_value.is_a?(FHIR::Bundle::Entry)
           slice_value.is_a? FHIR.const_get(discriminator[:code])
         end
       end

lib/inferno/dsl/must_support_assessment.rb

@@ -202,14 +202,18 @@ def must_support_extensions
         def missing_extensions(resources = [])
           @missing_extensions ||=
             must_support_extensions.select do |extension_definition|
+              expected_url = normalized_extension_url(extension_definition[:url])
+
               resources.none? do |resource|
                 path = extension_definition[:path]
 
                 if path == 'extension'
-                  resource.extension.any? { |extension| extension.url == extension_definition[:url] }
+                  Array.wrap(resource.extension).any? do |extension|
+                    normalized_extension_url(extension.url) == expected_url
+                  end
                 else
                   extension = find_a_value_at(resource, path) do |el|
-                    el.url == extension_definition[:url]
+                    normalized_extension_url(el.url) == expected_url
                   end
 
                   extension.present?
@@ -240,8 +244,9 @@ def resource_populates_element?(resource, element_definition)
 
           ms_extension_urls = must_support_extensions.select { |ex| ex[:path] == "#{path}.extension" }
             .map { |ex| ex[:url] }
+          include_dar = normalized_extension_urls(ms_extension_urls).include?(FHIRResourceNavigation::DAR_EXTENSION_URL)
 
-          value_found = find_a_value_at(resource, path) do |potential_value|
+          value_found = find_a_value_at(resource, path, include_dar:) do |potential_value|
             matching_without_extensions?(potential_value, ms_extension_urls, element_definition[:fixed_value])
           end
 
@@ -257,8 +262,11 @@ def process_must_support_element_in_extension(resource, path)
           extension_name = extension_split.first
           extension_path = extension_split.last
 
-          found_extension_url = must_support_extensions.find { |ex| ex[:id].include?(extension_name) }[:url]
-          ms_element_extension = resource.extension.find { |ex| ex.url == found_extension_url }
+          found_extension_url =
+            normalized_extension_url(must_support_extensions.find { |ex| ex[:id].include?(extension_name) }[:url])
+          ms_element_extension = resource.extension.find do |extension|
+            normalized_extension_url(extension.url) == found_extension_url
+          end
 
           if ms_element_extension.present?
             resource = ms_element_extension
@@ -269,17 +277,33 @@ def process_must_support_element_in_extension(resource, path)
         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
+          has_ms_extension = must_support_extension_present?(value, ms_extension_urls)
+
+          value = value.value if value.instance_of?(Inferno::DSL::PrimitiveType)
 
           return false unless has_ms_extension || value_without_extensions?(value)
 
           matches_fixed_value?(value, fixed_value)
         end
 
+        def must_support_extension_present?(value, ms_extension_urls)
+          return false unless value.respond_to?(:extension)
+
+          (extension_urls(value) & normalized_extension_urls(ms_extension_urls)).present?
+        end
+
+        def extension_urls(value)
+          Array.wrap(value.extension).map { |extension| normalized_extension_url(extension.url) }
+        end
+
+        def normalized_extension_urls(urls)
+          Array.wrap(urls).map { |url| normalized_extension_url(url) }
+        end
+
+        def normalized_extension_url(url)
+          url&.split('|')&.first
+        end
+
         def matches_fixed_value?(value, fixed_value)
           fixed_value.blank? || value == fixed_value
         end

lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -54,13 +54,17 @@ def must_support_extensions
           {
             id: element.id,
             path: element.path.gsub("#{resource}.", ''),
-            url: element.type.first.profile.first
+            url: canonical_url_without_version(element.type.first.profile.first)
           }.tap do |metadata|
             metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(element)
           end
         end
       end
 
+      def canonical_url_without_version(url)
+        url&.split('|')&.first
+      end
+
       def must_support_slice_elements
         all_must_support_elements.select do |element|
           !element.path.end_with?('extension') && element.sliceName.present?
@@ -153,24 +157,49 @@ def type_slices
         must_support_type_slice_elements.map do |current_element|
           discriminator = discriminators(sliced_element(current_element)).first
           type_path = discriminator_path(discriminator)
-          type_element = find_element_by_discriminator_path(current_element, type_path)
+          type_element, type_path = find_type_slice_target(current_element, type_path)
 
           type_code = type_element.type.first.code
+          discriminator_metadata = {
+            type: 'type',
+            code: type_code.upcase_first
+          }
+          discriminator_metadata[:path] = type_path if type_path.present?
 
           {
             slice_id: current_element.id,
             slice_name: current_element.sliceName,
             path: current_element.path.gsub("#{resource}.", ''),
-            discriminator: {
-              type: 'type',
-              code: type_code.upcase_first
-            }
+            discriminator: discriminator_metadata
           }.tap do |metadata|
             metadata[:by_requirement_extension_only] = true if by_requirement_extension_only?(current_element)
           end
         end
       end
 
+      def find_type_slice_target(current_element, type_path)
+        type_element = find_element_by_discriminator_path(current_element, type_path)
+
+        return [type_element, type_path] unless type_slice_requires_resource_path?(type_path, type_element)
+
+        resource_element = type_slice_resource_element(current_element)
+
+        return [type_element, type_path] unless resource_element.present?
+
+        [resource_element, resource_element.path.delete_prefix("#{current_element.path}.")]
+      end
+
+      def type_slice_requires_resource_path?(type_path, type_element)
+        type_path.blank? &&
+          type_element&.type&.all? { |type| type.code == 'BackboneElement' }
+      end
+
+      def type_slice_resource_element(current_element)
+        profile_elements.find do |element|
+          element.id == "#{current_element.id}.resource" && element.type.present?
+        end
+      end
+
       def must_support_value_slice_elements
         must_support_slice_elements.select do |element|
           # discriminator type 'pattern' is deprecated in FHIR R5 and made equivalent to 'value'

spec/fixtures/metadata/pas_inquiry_request_bundle_v220.yml

@@ -22,6 +22,7 @@
     :discriminator:
       :type: type
       :code: Claim
+      :path: resource
   :elements:
   - :path: identifier
   - :path: timestamp

spec/fixtures/metadata/pas_request_bundle_v201.yml

@@ -22,6 +22,7 @@
     :discriminator:
       :type: type
       :code: Claim
+      :path: resource
   :elements:
   - :path: identifier
   - :path: timestamp

spec/inferno/dsl/fhir_resource_navigation_spec.rb

@@ -173,15 +173,15 @@ def metadata_fixture(filename)
       expect(matcher).to_not be_matching_type_slice(slice, discriminator)
     end
 
-    it 'matches a Bundle::Entry by unwrapping resource when no discriminator path' do
+    it 'does not match a Bundle::Entry without a discriminator path' do
       slice = FHIR::Bundle::Entry.new(
         resource: FHIR::Claim.new
       )
       discriminator = { code: 'Claim' }
-      expect(matcher).to be_matching_type_slice(slice, discriminator)
+      expect(matcher).to_not be_matching_type_slice(slice, discriminator)
     end
 
-    it 'does not match a Bundle::Entry with wrong resource type when no discriminator path' do
+    it 'does not match a Bundle::Entry with the wrong resource type when no discriminator path' do
       slice = FHIR::Bundle::Entry.new(
         resource: FHIR::Patient.new
       )

spec/inferno/dsl/must_support_assessment_spec.rb

@@ -210,6 +210,92 @@ def run_with_metadata(resources, metadata)
     end
   end
 
+  describe 'must support test for versioned extension canonicals' do
+    let(:communication_request_metadata) do
+      OpenStruct.new(
+        must_supports: {
+          extensions: [
+            {
+              id: 'CommunicationRequest.extension:serviceLineNumber',
+              path: 'extension',
+              url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-serviceLineNumber|2.2.0'
+            },
+            {
+              id: 'CommunicationRequest.payload.extension:contentModifier',
+              path: 'payload.extension',
+              url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-contentModifier|2.2.0'
+            }
+          ],
+          slices: [],
+          elements: []
+        }
+      )
+    end
+
+    let(:communication_request) do
+      FHIR::CommunicationRequest.new(
+        extension: [
+          {
+            url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-serviceLineNumber',
+            valuePositiveInt: 1
+          }
+        ],
+        payload: [
+          {
+            extension: [
+              {
+                url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-contentModifier',
+                valueCodeableConcept: { text: 'modifier' }
+              }
+            ],
+            contentString: 'Need additional documentation'
+          }
+        ]
+      )
+    end
+
+    it 'matches resource extensions when metadata canonical urls include a version' do
+      result = run_with_metadata([communication_request], communication_request_metadata)
+      expect(result).to be_empty
+    end
+  end
+
+  describe 'must support test for non-primitive elements with must support extensions' do
+    let(:claim_response_metadata) do
+      OpenStruct.new(
+        must_supports: {
+          extensions: [
+            {
+              id: 'ClaimResponse.request.extension:DataAbsentReason',
+              path: 'request.extension',
+              url: 'http://hl7.org/fhir/StructureDefinition/data-absent-reason|5.2.0'
+            }
+          ],
+          slices: [],
+          elements: [{ path: 'request' }]
+        }
+      )
+    end
+
+    let(:claim_response) do
+      FHIR::ClaimResponse.new(
+        request: {
+          extension: [
+            {
+              url: 'http://hl7.org/fhir/StructureDefinition/data-absent-reason',
+              valueCode: 'unknown'
+            }
+          ]
+        }
+      )
+    end
+
+    it 'treats a DAR-only reference as populated when the extension is must support' do
+      result = run_with_metadata([claim_response], claim_response_metadata)
+      expect(result).to be_empty
+    end
+  end
+
   describe 'must support test for slices' do
     context 'with patternCodeableConcept slicing' do
       let(:careplan_profile) { fixture('StructureDefinition-us-core-careplan.json') }

spec/inferno/dsl/must_support_metadata_extractor_spec.rb

@@ -1,3 +1,4 @@
+require_relative '../../extract_tgz_helper'
 require_relative '../../../lib/inferno/dsl/must_support_metadata_extractor'
 
 RSpec.describe Inferno::DSL::MustSupportMetadataExtractor do
@@ -31,6 +32,20 @@
     allow(profile_element).to receive_messages(mustSupport: true, path: 'foo.extension', id: 'id', type: [type])
   end
 
+  describe '#must_support_extensions' do
+    let(:type) do
+      type = double
+      allow(type).to receive(:profile).and_return(['http://example.org/StructureDefinition/example-extension|1.2.3'])
+      type
+    end
+
+    it 'removes canonical version suffixes from extension urls' do
+      expect(extractor.must_support_extensions).to eq(
+        [{ id: 'id', path: 'foo.extension', url: 'http://example.org/StructureDefinition/example-extension' }]
+      )
+    end
+  end
+
   describe '#get_type_must_support_metadata' do
     let(:metadata) do
       { path: 'path' }
@@ -87,6 +102,65 @@
       expect(slices[0][:discriminator][:type]).to eq('type')
       expect(slices[0][:discriminator][:code]).to eq('Date')
     end
+
+    it 'extracts the discriminator path when the sliced type is on Bundle.entry.resource' do
+      discriminator = FHIR::ElementDefinition::Slicing::Discriminator.new(type: 'type', path: '$this')
+      slicing = FHIR::ElementDefinition::Slicing.new(discriminator: [discriminator])
+
+      backbone_type = instance_double(FHIR::ElementDefinition::Type, code: 'BackboneElement')
+      claim_type = instance_double(FHIR::ElementDefinition::Type, code: 'Claim')
+      bundle_profile = instance_double(
+        FHIR::StructureDefinition,
+        baseDefinition: 'baseDefinition',
+        name: 'bundle',
+        type: 'Bundle',
+        version: '2.2.0'
+      )
+      profile_elements = [
+        instance_double(
+          FHIR::ElementDefinition,
+          id: 'Bundle.entry',
+          path: 'Bundle.entry',
+          sliceName: nil,
+          mustSupport: false,
+          slicing:,
+          type: [backbone_type]
+        ),
+        instance_double(
+          FHIR::ElementDefinition,
+          id: 'Bundle.entry:Claim',
+          path: 'Bundle.entry',
+          sliceName: 'Claim',
+          mustSupport: true,
+          slicing: nil,
+          type: [backbone_type]
+        ),
+        instance_double(
+          FHIR::ElementDefinition,
+          id: 'Bundle.entry:Claim.resource',
+          path: 'Bundle.entry.resource',
+          sliceName: nil,
+          mustSupport: false,
+          slicing: nil,
+          type: [claim_type]
+        )
+      ]
+
+      slices = described_class.new(profile_elements, bundle_profile, 'Bundle', ig_resources).type_slices
+
+      expect(slices).to contain_exactly(
+        {
+          slice_id: 'Bundle.entry:Claim',
+          slice_name: 'Claim',
+          path: 'entry',
+          discriminator: {
+            type: 'type',
+            code: 'Claim',
+            path: 'resource'
+          }
+        }
+      )
+    end
   end
 
   describe '#value_slices' do