us_core_test_kit 0.10.1 → 0.11.1

data/lib/us_core_test_kit/granular_scope_read_test.rb

@@ -22,7 +22,7 @@ module USCoreTestKit
               "No #{resource_type} reads found"
       previous_resources_for_reads = previous_request_resources.values.flatten
 
-      resource_specific_granular_scope_search_params.each do |scope| 
+      resource_specific_granular_scope_search_params.each do |scope|
         current_scope = granular_scopes.find {|granular| granular.include?(scope[:name]) && granular.include?(scope[:value])}
 
         resource_matching_scope = previous_resources_for_reads.find do |prev_resource|
@@ -37,19 +37,26 @@ module USCoreTestKit
       end
 
       nonmatching_resource = previous_resources_for_reads.find do |prev_resource|
-        resource_specific_granular_scope_search_params.none? do |scope| 
+        resource_specific_granular_scope_search_params.none? do |scope|
           resource_matches_param?(prev_resource, scope[:name], scope[:value])
         end
       end
       if nonmatching_resource
         fhir_read resource_type, nonmatching_resource.id
         assert (response && response[:status]) != 200, "Server incorrectly responded with a successful status, read should fail due to scopes."
-        assert (resource && resource.resourceType != resource_type), "Server incorrectly returned a #{resource_type}, read should fail due to scopes"
+
+        begin
+          res = resource
+        rescue NoMethodError
+          res = nil
+        end
+
+        assert (!res || res.resourceType == 'OperationOutcome'), "Read shall fail due to scopes. Server shall return 4xx status code with an optional OperationOutcome payload."
       else
         info "Unable to find a resource that does not match scopes."
       end
     end
-    
+
     def load_previous_requests
       params = metadata.searches.first[:names]
       search_params_as_hash = params.each_with_object({}) do |name, hash|

data/lib/us_core_test_kit/must_support_test.rb

@@ -14,221 +14,7 @@ module USCoreTestKit
     def perform_must_support_test(resources)
       skip_if resources.blank?, "No #{resource_type} resources were found"
 
-      missing_elements(resources)
-      missing_slices(resources)
-      missing_extensions(resources)
-
-      handle_must_support_choices if metadata.must_supports[:choices].present?
-
-      if (missing_elements + missing_slices + missing_extensions).length.zero?
-        pass
-      end
-      skip "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
-           "provided #{resource_type} resource(s)"
-    end
-
-    def handle_must_support_choices
-      missing_elements.delete_if do |element|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:paths]&.include?(element[:path]) }
-        is_any_choice_supported?(choices)
-      end
-
-      missing_extensions.delete_if do |extension|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:extension_ids]&.include?(extension[:id]) }
-        is_any_choice_supported?(choices)
-      end
-
-      missing_slices.delete_if do |slice|
-        choices = metadata.must_supports[:choices].find { |choice| choice[:slice_names]&.include?(slice[:name]) }
-        is_any_choice_supported?(choices)
-      end
-    end
-
-    def is_any_choice_supported? (choices)
-      choices.present? &&
-      (
-        choices[:paths]&.any? { |path| missing_elements.none? { |element| element[:path] == path } } ||
-        choices[:extension_ids]&.any? { |extension_id| missing_extensions.none? { |extension| extension[:id] == extension_id} } ||
-        choices[:slice_names]&.any? { |slice_name| missing_slices.none? { |slice| slice[:name] == slice_name} }
-      )
-    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 exclude_uscdi_only_test?
-      config.options[:exclude_uscdi_only_test] == true
-    end
-
-    def must_support_extensions
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:extensions].reject{ |extension| extension[:uscdi_only] }
-      else
-        metadata.must_supports[:extensions]
-      end
-    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
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:elements].reject{ |element| element[:uscdi_only] }
-      else
-        metadata.must_supports[:elements]
-      end
-    end
-
-    def missing_elements(resources = [])
-      @missing_elements ||= find_missing_elements(resources, must_support_elements)
-      @missing_elements
-    end
-
-    def find_missing_elements(resources, must_support_elements)
-      must_support_elements.select do |element_definition|
-        resources.none? do |resource|
-          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 |value|
-            if value.instance_of?(USCoreTestKit::PrimitiveType) && ms_extension_urls.present?
-              urls = value.extension&.map(&:url)
-              has_ms_extension = (urls & ms_extension_urls).present?
-            end
-
-            unless has_ms_extension
-              value = value.value if value.instance_of?(USCoreTestKit::PrimitiveType)
-              value_without_extensions =
-                value.respond_to?(:to_hash) ? value.to_hash.reject { |key, _| key == 'extension' } : value
-            end
-
-            (has_ms_extension || value_without_extensions.present? || value_without_extensions == false) &&
-              (element_definition[:fixed_value].blank? || value == 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
-      end
-    end
-
-    def must_support_slices
-      if exclude_uscdi_only_test?
-        metadata.must_supports[:slices].reject{ |slice| slice[:uscdi_only] }
-      else
-        metadata.must_supports[:slices]
-      end
-    end
-
-    def missing_slices(resources = [])
-      @missing_slices ||=
-        must_support_slices.select do |slice|
-          resources.none? do |resource|
-            path = slice[:path] # .delete_suffix('[x]')
-            find_slice(resource, path, slice[:discriminator]).present?
-          end
-        end
-    end
-
-    def find_slice(resource, path, discriminator)
-      find_a_value_at(resource, path) do |element|
-        case discriminator[:type]
-        when 'patternCodeableConcept'
-          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
-        when 'patternCoding'
-          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
-        when 'patternIdentifier'
-          find_a_value_at(element, discriminator[:path]) { |identifier| identifier.system == discriminator[:system] }
-        when 'value'
-          values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
-          find_slice_by_values(element, values)
-        when 'type'
-          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
-        when 'requiredBinding'
-          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
-      end
-    end
-
-    def find_slice_by_values(element, value_definitions)
-      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
-      Array.wrap(element).find do |el|
-        path_prefixes.all? do |path_prefix|
-          value_definitions_for_path =
-            value_definitions
-              .select { |value_definition| value_definition[:path].first == path_prefix }
-              .each { |value_definition| value_definition[:path].shift }
-
-          find_a_value_at(el, path_prefix) do |el_found|
-            child_element_value_definitions, current_element_value_definitions =
-              value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
-
-            current_element_values_match =
-              current_element_value_definitions
-                .all? { |value_definition| value_definition[:value] == el_found }
-
-            child_element_values_match =
-              child_element_value_definitions.present? ?
-                find_slice_by_values(el_found, child_element_value_definitions) : true
-
-            current_element_values_match && child_element_values_match
-          end
-        end
-      end
+      skip { assert_must_support_elements_present(resources, nil, metadata:) }
     end
   end
 end

data/lib/us_core_test_kit/practitioner_address_test.rb

@@ -25,7 +25,7 @@ module USCoreTestKit
 
     def verify_practitioner_address
       references = scratch.dig(:references, 'Practitioner')
-      assert references.any?, 'No Pracitioner references found.'
+      assert references.any?, 'No Practitioner references found.'
 
       @missing_elements = MUST_SUPPORT_ELEMENTS
       practitioners = []

data/lib/us_core_test_kit/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module USCoreTestKit
-  VERSION = '0.10.1'
-  LAST_UPDATED = '2025-02-25'
+  VERSION = '0.11.1'
+  LAST_UPDATED = '2025-04-07'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: us_core_test_kit
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.1
 platform: ruby
 authors:
 - Stephen MacVicar
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-25 00:00:00.000000000 Z
+date: 2025-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inferno_core
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.8
 - !ruby/object:Gem::Dependency
   name: smart_app_launch_test_kit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.1
 - !ruby/object:Gem::Dependency
   name: tls_test_kit
   requirement: !ruby/object:Gem::Requirement