inferno_core 1.4.4 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8c3149fd821b0530f7481d6a01bdef6da32263f1cca74f7b852567edb67af43
-  data.tar.gz: df8cd12ccb8054d182655c7537c730cd0a1f6fa538552e98171b93c43300d17b
+  metadata.gz: 8cffc2d9b151af63840789863f04e8551fd82077351f85d356b5a88f103f28f2
+  data.tar.gz: c6687758255cf5acadb700dfd268ee65f6ab03713dbc17ec412d1240d7f352b7
 SHA512:
-  metadata.gz: f6d6c9b29f44b0f3169bee590aac204520aa3fc24d651443b5136958cecfffc889d71172881b4c97323b6b17b65d78afd8fd8027a0b8d933037023345fed975d
-  data.tar.gz: 196c88889027e64aa05e3e7a9997749c9dfc5fab9fecdfa1a40437005d2cfd9a5390945f3efc3382ae4c2a3ea3f208ebc5720b5837ca1ad46fd5f08dfdab8678
+  metadata.gz: 0f7ca455177f14a4f0ad5dae5852a7b7441e7ef867e554678b8d55410d623cb7b1d0e4e4432dbd8f1c8cdc085943801d2b98601d9ea776cd1e93f6482a02e3b9
+  data.tar.gz: d4160ba11c06d24fc185c2b4cde86fc36c519499f383c79053246114b2e69d0e5be4504e87ea476f462e1439383f8c1a07a5efcab2701449cbd6458939faa13b

data/lib/inferno/apps/cli/templates/%library_name%.gemspec.tt

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   # DESCRIPTION
   # spec.homepage      = 'TODO'
   spec.license       = 'Apache-2.0'
-  spec.add_dependency 'inferno_core', '~> <%= Inferno::VERSION %>'
+  spec.add_dependency 'inferno_core', '~> <%= Inferno::VERSION.split('.').first(2).join('.') %>', '>= <%= Inferno::VERSION %>'
   spec.required_ruby_version = Gem::Requirement.new('>= 3.3.6')
   spec.metadata['inferno_test_kit'] = 'true'
   # spec.metadata['homepage_uri'] = spec.homepage

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

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

data/lib/inferno/apps/cli/templates/execution_scripts/%library_name%_script_expected.json.tt

@@ -126,18 +126,10 @@
         "message": "Patient/85: Patient.extension[0]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-race",
         "type": "info"
       },
-      {
-        "message": "Patient/85: Patient.extension[0].extension[0].value.ofType(Coding): The definition for the Code System with URI 'urn:oid:2.16.840.1.113883.6.238' doesn't provide any codes so the code cannot be validated",
-        "type": "info"
-      },
       {
         "message": "Patient/85: Patient.extension[1]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity",
         "type": "info"
       },
-      {
-        "message": "Patient/85: Patient.extension[1].extension[0].value.ofType(Coding): The definition for the Code System with URI 'urn:oid:2.16.840.1.113883.6.238' doesn't provide any codes so the code cannot be validated",
-        "type": "info"
-      },
       {
         "message": "Patient/85: Patient.extension[2]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex",
         "type": "info"

data/lib/inferno/apps/cli/templates/spec/%library_name%/patient_group_spec.rb.tt

@@ -46,7 +46,7 @@ RSpec.describe <%= module_name %>::PatientGroup do
       result = run(test, url: url, patient_id: patient_id)
 
       expect(result.result).to eq('fail'), result.result_message
-      expect(result.result_message).to match(/200/)
+      expect(result.result_message).to include('200')
     end
 
     it 'fails if a Patient is not received' do
@@ -57,7 +57,7 @@ RSpec.describe <%= module_name %>::PatientGroup do
       result = run(test, url: url, patient_id: patient_id)
 
       expect(result.result).to eq('fail'), result.result_message
-      expect(result.result_message).to match(/Patient/)
+      expect(result.result_message).to include('Patient')
     end
 
     it 'fails if the id received does not match the one requested' do
@@ -68,7 +68,7 @@ RSpec.describe <%= module_name %>::PatientGroup do
       result = run(test, url: url, patient_id: patient_id)
 
       expect(result.result).to eq('fail'), result.result_message
-      expect(result.result_message).to match(/resource with id/)
+      expect(result.result_message).to include('resource with id')
     end
   end
 

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

@@ -1,3 +1,36 @@
+module Inferno
+  module Config
+    module Boot
+      # Extracted from the :suites provider below so the enable_when
+      # validation can be unit tested against plain Test/TestGroup/TestSuite
+      # classes, instead of requiring a full application boot (which only
+      # happens once per process) just to exercise the raise.
+      module Suites
+        module_function
+
+        # A circular or undefined enable_when dependency means the input
+        # involved can never be enabled, so this is treated as fatal at load
+        # time rather than left for developers to discover once the suite is
+        # already running. `enable_when` is uninheritable, so a problem local
+        # to a group or test can be hidden from the suite's own merged view if
+        # a parent re-declares the same input name without repeating
+        # `enable_when` -- checking every runnable in the tree, not just the
+        # suite, is what catches that case.
+        def check_enable_when_errors!(descendant)
+          [*descendant.all_descendants.reverse, descendant].each do |runnable|
+            enable_when_errors = runnable.enable_when_problem_messages
+            next if enable_when_errors.empty?
+
+            raise StandardError,
+                  "Error initializing test suite #{descendant.name} (id: #{descendant.id}) " \
+                  "in '#{runnable.title || runnable.id}' (id: #{runnable.id}):\n- #{enable_when_errors.join("\n- ")}"
+          end
+        end
+      end
+    end
+  end
+end
+
 Inferno::Application.register_provider(:suites) do
   prepare do
     target_container.start :logging
@@ -46,6 +79,8 @@ Inferno::Application.register_provider(:suites) do
         raise StandardError, "Error initializing test suite #{descendant.name}: test suite ID is not set"
       end
 
+      Inferno::Config::Boot::Suites.check_enable_when_errors!(descendant)
+
       # This will lock the short IDs if a short ID map for this suite is present
       descendant.assign_short_ids
     end

data/lib/inferno/dsl/input_output_handling.rb

@@ -16,7 +16,8 @@ module Inferno
       # @option input_params [Hash] :options Possible input option formats based on input type
       # @option options [Array] :list_options Array of options for input formats
       #   that require a list of possible values (radio and checkbox)
-      # @option input_params [Hash] :enable_when Conditions for showing the input. Must be a Hash
+      # @option input_params [Hash] :enable_when Conditions for showing the input and determining
+      #   whether it is required. Must be a Hash
       #   with String :input_name (the name of the controlling input) and String :value (the value
       #   that triggers visibility). For checkbox inputs the value must be a JSON-encoded sorted
       #   array, e.g. '["a","b"]'.
@@ -97,9 +98,12 @@ module Inferno
       end
 
       # @private
-      def required_inputs(selected_suite_options)
-        available_inputs(selected_suite_options)
-          .reject { |_, input| input.optional }
+      def required_inputs(selected_suite_options, submitted_inputs = nil)
+        input_values = (submitted_inputs || []).to_h { |input| [input[:name].to_s, input[:value]] }
+
+        available = available_inputs(selected_suite_options)
+        available
+          .reject { |_, input| input.optional || !input.enabled?(input_values, available) }
           .map { |_, input| input.name }
       end
 
@@ -107,7 +111,10 @@ module Inferno
       def missing_inputs(submitted_inputs, selected_suite_options)
         submitted_inputs = [] if submitted_inputs.nil?
 
-        required_inputs(selected_suite_options).map(&:to_s) - submitted_inputs.map { |input| input[:name] }
+        required_input_names = required_inputs(selected_suite_options, submitted_inputs).map(&:to_s)
+        submitted_input_names = submitted_inputs.map { |input| input[:name] }
+
+        required_input_names - submitted_input_names
       end
 
       # Define a particular order for inputs to be presented in the API/UI
@@ -204,6 +211,95 @@ module Inferno
 
         order_available_inputs(child_inputs.merge(available_inputs))
       end
+
+      # @private
+      # Automatically detect, among this runnable's own inputs: circular
+      # `enable_when` dependencies (e.g. input `a` is enabled_when `b`, which
+      # is itself enabled_when `a`), and `enable_when` conditions that
+      # reference an input not declared on this same runnable (e.g. a typo'd
+      # `input_name`). Both silently evaluate as permanently disabled at
+      # runtime with no other diagnostic (see `Entities::Input#enabled?`'s
+      # `visited` guard and its `input_values.key?` check), so they're
+      # treated as fatal at load time instead. Note `enable_when` is an
+      # uninheritable attribute -- it only has meaning, and can only
+      # reference another input, at the level it's declared -- so a problem
+      # local to a group or test can be masked if a parent re-declares the
+      # same input name without repeating `enable_when`; checking every
+      # runnable in the tree (not just the suite) is what catches those.
+      def enable_when_problem_messages
+        inputs_by_name = enable_when_local_inputs
+        edges = enable_when_edges(inputs_by_name)
+
+        enable_when_undefined_reference_messages(edges, inputs_by_name) + enable_when_calculated_cycle_messages(edges)
+      end
+
+      # @private
+      # Flags any `enable_when.input_name` that doesn't name an input
+      # declared on this same runnable.
+      def enable_when_undefined_reference_messages(edges, inputs_by_name)
+        local_names = inputs_by_name.values.map(&:name)
+
+        edges.filter_map do |name, referenced_name|
+          next if local_names.include?(referenced_name)
+
+          "Input '#{name}' has an enable_when condition that references '#{referenced_name}', " \
+            'which is not an input defined on the same test/group/suite.'
+        end
+      end
+
+      # @private
+      def enable_when_calculated_cycle_messages(edges)
+        globally_visited = {}
+
+        edges.each_key.filter_map do |start_name|
+          next if globally_visited[start_name]
+
+          cycle = follow_enable_when_chain(start_name, edges, globally_visited)
+          next unless cycle
+
+          chain = (cycle + [cycle.first]).join(' -> ')
+          "Circular enable_when dependency detected in input '#{cycle.first}': #{chain}. "
+        end
+      end
+
+      # @private
+      # Maps each input's name to the name of the input it depends on via
+      # `enable_when`, for every input in this runnable that has one.
+      # `enable_when` is uninheritable (see `Entities::Input::UNINHERITABLE_ATTRIBUTES`),
+      # so it's unaffected by the child merge in `available_inputs` -- reading
+      # straight from this runnable's own local input config avoids that
+      # merge's subtree walk entirely.
+      def enable_when_edges(inputs_by_name = enable_when_local_inputs)
+        inputs_by_name.each_with_object({}) do |(_, input), depends_on|
+          depends_on[input.name] = input.enable_when[:input_name] if input.enable_when.present?
+        end
+      end
+
+      # @private
+      def enable_when_local_inputs
+        config.inputs.slice(*inputs)
+      end
+
+      # @private
+      # Follows the `enable_when` chain starting at `start_name`, marking
+      # every node visited along the way. Returns the cycle (as an array of
+      # input names) if one is found, otherwise nil.
+      def follow_enable_when_chain(start_name, depends_on, globally_visited)
+        path = []
+        node = start_name
+
+        until node.nil? || globally_visited[node]
+          break if path.index(node)
+
+          path << node
+          node = depends_on[node]
+        end
+
+        path.each { |name| globally_visited[name] = true }
+
+        cycle_start_index = path.index(node)
+        cycle_start_index && path[cycle_start_index..]
+      end
     end
   end
 end

data/lib/inferno/dsl/must_support_metadata_extractor.rb

@@ -75,7 +75,20 @@ module Inferno
       end
 
       def all_must_support_elements
-        profile_elements.select { |element| element.mustSupport || by_requirement_extension_only?(element) }
+        profile_elements.select do |element|
+          (element.mustSupport || by_requirement_extension_only?(element)) && !prohibited_by_cardinality?(element)
+        end
+      end
+
+      # A profile can inherit mustSupport flags from a base profile while constraining the element to a max
+      # cardinality of 0. Such an element, and its descendants, cannot appear in a conformant resource.
+      def prohibited_by_cardinality?(element)
+        profile_elements.any? do |profile_element|
+          profile_element.max == '0' &&
+            (element.id == profile_element.id ||
+              element.id.start_with?("#{profile_element.id}.") ||
+              element.id.start_with?("#{profile_element.id}:"))
+        end
       end
 
       def must_support_extension_elements
@@ -364,6 +377,11 @@ module Inferno
                   path: navigation_compatible_discriminator_path(discriminator_path),
                   value: pattern_element.fixed
                 }
+              elsif pattern_element.patternString
+                fixed_values << {
+                  path: navigation_compatible_discriminator_path(discriminator_path),
+                  value: pattern_element.patternString
+                }
               elsif pattern_value.present?
                 raise StandardError, "Found more than one pattern slices for the same element #{pattern_element}."
               else

data/lib/inferno/entities/input.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 require_relative 'attributes'
 require_relative '../exceptions'
 
@@ -91,6 +93,30 @@ module Inferno
         type_is_hash && input_name_string_exists && value_string_exists
       end
 
+      # @private
+      # Whether this input is enabled for a map of submitted input values.
+      # An input without an enable_when condition is always enabled. An input
+      # whose controlling input is itself conditionally disabled (i.e. has its
+      # own enable_when condition that is not met) is never enabled, regardless
+      # of the controlling input's current value.
+      # @param visited [Array<Symbol>] names of inputs already visited in this
+      #   evaluation chain, used to guard against circular enable_when references.
+      def enabled?(input_values, available_inputs, visited = [])
+        return true if enable_when.blank?
+        return false if visited.include?(name)
+        return false unless input_values.key?(enable_when[:input_name])
+
+        controlling_input = available_inputs[enable_when[:input_name].to_sym]
+        if controlling_input && !controlling_input.enabled?(input_values, available_inputs, visited + [name])
+          return false
+        end
+
+        return checkbox_group_enabled?(input_values[enable_when[:input_name]]) if checkbox_group?(controlling_input)
+
+        normalize_enable_when_value(input_values[enable_when[:input_name]]) ==
+          normalize_enable_when_value(enable_when[:value])
+      end
+
       # @private
       # Merge this input with an input belonging to a child. Fields defined on
       # this input take precedence over those defined on the child input.
@@ -211,6 +237,37 @@ module Inferno
 
         ATTRIBUTES.all? { |attribute| send(attribute) == other.send(attribute) }
       end
+
+      private
+
+      def checkbox_group?(input)
+        input&.type.to_s == 'checkbox' && input.options&.dig(:list_options)&.any?
+      end
+
+      def checkbox_group_enabled?(value)
+        actual_values = normalize_checkbox_values(value)
+        expected_values = normalize_checkbox_values(enable_when[:value])
+        !actual_values.nil? && actual_values == expected_values
+      end
+
+      def normalize_checkbox_values(value)
+        value = JSON.parse(value) if value.is_a?(String)
+        return unless value.is_a?(Array) && value.all? { |item| item.is_a?(String) }
+
+        value.sort
+      rescue JSON::ParserError
+        nil
+      end
+
+      # Normalize values using the same rules as the client-side enable_when
+      # comparison for non-checkbox-group inputs.
+      def normalize_enable_when_value(value)
+        return '' if value.nil?
+        return JSON.generate(value.sort_by(&:to_s)) if value.is_a?(Array)
+        return JSON.generate(value) if value.is_a?(Hash)
+
+        value.to_s
+      end
     end
   end
 end