inferno_core 0.2.0 → 0.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b081a1dec3c7c5c80fc8d2423bb1f3b3799be30f8173c73b1dce28f7095a419
-  data.tar.gz: d5c378788719ee610edfced2133abb8ff5a20637d28c1405f3ff19fa0219fe1a
+  metadata.gz: 2d689ccce031c3a119965c25c083606b6f5a789c61b29dca2b50971872205d47
+  data.tar.gz: 1be92b3799e22400b7d37ac1780de257c3104d23e809b712ee543b5437af8ecd
 SHA512:
-  metadata.gz: 2cbdecf407e35cd80d5601173ef3b0e464c961e7f919fdec5e1b5b05449b67229e2fa34301bdccb53fc324768c5aab1cbb60e8cbe3bc635989d6cec27ef9708c
-  data.tar.gz: 977fe89c0e3968ce13d80d771a45c936c66e427b0b39c4cc8af14f0992775590d37885bf135db58b91419fab1e371a0d3b9c86aaf2e96ce6d35dbfdbe4e90dcd
+  metadata.gz: 563d0d578f6cc039ef95e3e5cc81b2285da6a04779e6705462111a626e826cd47cb2c82dd26dbd00f048d6e4f7277761151351da27e30a0ba3cbb64f6086440e
+  data.tar.gz: cda50085e8e67e5737a06b3440b2533804251d9eea5aff2235e28c9039387ca352aaa72b45f46e00e859adb8d8bfc5d83f63a0851c58c2d71dff5844ef35d5a7

data/lib/inferno/apps/web/controllers/test_runs/create.rb

@@ -11,6 +11,36 @@ module Inferno
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
 
+          def verify_runnable(runnable, inputs)
+            missing_inputs = runnable&.missing_inputs(inputs)
+            user_runnable = runnable&.user_runnable?
+            raise Inferno::Exceptions::RequiredInputsNotFound, missing_inputs if missing_inputs&.any?
+            raise Inferno::Exceptions::NotUserRunnableException unless user_runnable
+          end
+
+          def persist_inputs(params, test_run)
+            params[:inputs]&.each do |input_params|
+              input =
+                test_run.runnable.available_inputs
+                  .find { |_, runnable_input| runnable_input.name == input_params[:name] }
+                  &.last
+
+              if input.nil?
+                Inferno::Application['logger'].warning(
+                  "Unknown input `#{input_params[:name]}` for #{test_run.runnable.id}: #{test_run.runnable.title}"
+                )
+                next
+              end
+
+              session_data_repo.save(
+                test_session_id: test_run.test_session_id,
+                name: input.name,
+                value: input_params[:value],
+                type: input.type
+              )
+            end
+          end
+
           def call(params)
             test_session = test_sessions_repo.find(params[:test_session_id])
 
@@ -21,24 +51,13 @@ module Inferno
               return
             end
 
-            # TODO: This test run shouldn't be created until after the inputs
-            # and runnable are validated
-            test_run = repo.create(create_params(params).merge(status: 'queued'))
-            missing_inputs = test_run.runnable.missing_inputs(params[:inputs])
+            verify_runnable(repo.build_entity(create_params(params)).runnable, params[:inputs])
 
-            raise Inferno::Exceptions::RequiredInputsNotFound, missing_inputs if missing_inputs.any?
-            raise Inferno::Exceptions::NotUserRunnableException unless test_run.runnable.user_runnable?
+            test_run = repo.create(create_params(params).merge(status: 'queued'))
 
             self.body = serialize(test_run)
 
-            params[:inputs]&.each do |input|
-              session_data_repo.save(
-                test_session_id: test_session.id,
-                name: input[:name],
-                value: input[:value],
-                type: input[:type]
-              )
-            end
+            persist_inputs(params, test_run)
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,

data/lib/inferno/apps/web/index.html.erb

@@ -25,11 +25,26 @@
       work correctly both with client-side routing and a non-root public URL.
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
+    <style>
+      .wrapper {
+        height: 100%;
+        display: flex;
+        flex-direction: column;
+      }
+      .app {
+        height: 100%;
+      }
+    </style>
     <title>Inferno</title>
   </head>
   <body>
     <noscript>You need to enable JavaScript to run this app.</noscript>
-    <div id="root"></div>
+    <div class='wrapper'>
+      <% if File.exist? (File.join(Dir.pwd, 'config', 'banner.html.erb')) %>
+        <div class='banner'><%= ERB.new(File.read(File.join(Dir.pwd, 'config', 'banner.html.erb'))).result %></div> 
+      <% end %>
+      <div class='app' id="root"></div>
+    </div>
     <!--
       This HTML file is a template.
       If you open it directly in the browser, you will see an empty page.

data/lib/inferno/apps/web/serializers/result.rb

@@ -18,6 +18,10 @@ module Inferno
         field :updated_at
         field :optional?, name: :optional
 
+        field :inputs do |result, _options|
+          result.input_json.present? ? JSON.parse(result.input_json) : []
+        end
+
         field :outputs do |result, _options|
           result.output_json.present? ? JSON.parse(result.output_json) : []
         end

data/lib/inferno/apps/web/serializers/test.rb

@@ -7,7 +7,7 @@ module Inferno
         field :short_id
         field :title
         field :short_title
-        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :available_inputs, name: :inputs, extractor: HashValueExtractor, blueprint: Input
         field :output_definitions, name: :outputs, extractor: HashValueExtractor
         field :description
         field :short_description

data/lib/inferno/apps/web/serializers/test_group.rb

@@ -17,7 +17,7 @@ module Inferno
 
         association :groups, name: :test_groups, blueprint: TestGroup
         association :tests, blueprint: Test
-        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :available_inputs, name: :inputs, extractor: HashValueExtractor, blueprint: Input
         field :output_definitions, name: :outputs, extractor: HashValueExtractor
       end
     end

data/lib/inferno/apps/web/serializers/test_suite.rb

@@ -18,6 +18,7 @@ module Inferno
           include_view :summary
           association :groups, name: :test_groups, blueprint: TestGroup
           field :configuration_messages
+          field :available_inputs, name: :inputs, extractor: HashValueExtractor, blueprint: Input
         end
       end
     end

data/lib/inferno/dsl/configurable.rb

@@ -1,3 +1,5 @@
+require_relative '../entities/input'
+
 module Inferno
   module DSL
     # This module contains the DSL for managing runnable configuration.
@@ -35,7 +37,11 @@ module Inferno
               new_configuration
             end
 
-          self.configuration = configuration.deep_merge(config_to_apply)
+          self.configuration = configuration.deep_merge(config_to_apply.reject { |key, _| key == :inputs })
+
+          config_to_apply[:inputs]&.each do |identifier, new_input|
+            add_input(identifier, new_input.to_hash)
+          end
         end
 
         def options
@@ -49,28 +55,36 @@ module Inferno
         end
 
         def add_input(identifier, new_config = {})
-          existing_config = input_config(identifier) || {}
-          inputs[identifier] = default_input_config(identifier).merge(existing_config, new_config)
+          existing_config = input(identifier)
+
+          if existing_config.nil?
+            return inputs[identifier] = Entities::Input.new(default_input_params(identifier).merge(new_config))
+          end
+
+          inputs[identifier] =
+            Entities::Input
+              .new(existing_config.to_hash)
+              .merge(Entities::Input.new(new_config))
         end
 
-        def default_input_config(identifier)
+        def default_input_params(identifier)
           { name: identifier, type: 'text' }
         end
 
-        def input_config_exists?(identifier)
+        def input_exists?(identifier)
           inputs.key? identifier
         end
 
-        def input_config(identifier)
+        def input(identifier)
           inputs[identifier]
         end
 
         def input_name(identifier)
-          inputs.dig(identifier, :name) || identifier
+          inputs[identifier]&.name
         end
 
         def input_type(identifier)
-          inputs.dig(identifier, :type)
+          inputs[identifier]&.type
         end
 
         ### Output Configuration ###

data/lib/inferno/dsl/fhir_validation.rb

@@ -1,3 +1,5 @@
+require_relative '../ext/fhir_models'
+
 module Inferno
   module DSL
     # This module contains the methods needed to configure a validator to
@@ -168,7 +170,7 @@ module Inferno
         def validate(resource, profile_url)
           RestClient.post(
             "#{url}/validate",
-            resource.to_json,
+            resource.source_contents,
             params: { profile: profile_url }
           ).body
         end

data/lib/inferno/dsl/input_output_handling.rb

@@ -0,0 +1,185 @@
+module Inferno
+  module DSL
+    module InputOutputHandling
+      # Define inputs
+      #
+      # @param identifier [Symbol] identifier for the input
+      # @param other_identifiers [Symbol] array of symbols if specifying multiple inputs
+      # @param input_params [Hash] options for input such as type, description, or title
+      # @option input_params [String] :title Human readable title for input
+      # @option input_params [String] :description Description for the input
+      # @option input_params [String] :type text | textarea | radio
+      # @option input_params [String] :default The default value for the input
+      # @option input_params [Boolean] :optional Set to true to not require input for test execution
+      # @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
+      # @return [void]
+      # @example
+      #   input :patient_id, title: 'Patient ID', description: 'The ID of the patient being searched for',
+      #                     default: 'default_patient_id'
+      # @example
+      #   input :textarea, title: 'Textarea Input Example', type: 'textarea', optional: true
+      def input(identifier, *other_identifiers, **input_params)
+        if other_identifiers.present?
+          [identifier, *other_identifiers].compact.each do |input_identifier|
+            inputs << input_identifier
+            config.add_input(input_identifier)
+          end
+        else
+          inputs << identifier
+          config.add_input(identifier, input_params)
+        end
+      end
+
+      # Define outputs
+      #
+      # @param identifier [Symbol] identifier for the output
+      # @param other_identifiers [Symbol] array of symbols if specifying multiple outputs
+      # @param output_definition [Hash] options for output
+      # @option output_definition [String] :type text | textarea | oauth_credentials
+      # @return [void]
+      # @example
+      #   output :patient_id, :condition_id, :observation_id
+      # @example
+      #   output :oauth_credentials, type: 'oauth_credentials'
+      def output(identifier, *other_identifiers, **output_definition)
+        if other_identifiers.present?
+          [identifier, *other_identifiers].compact.each do |output_identifier|
+            outputs << output_identifier
+            config.add_output(output_identifier)
+          end
+        else
+          outputs << identifier
+          config.add_output(identifier, output_definition)
+        end
+      end
+
+      # @private
+      def inputs
+        @inputs ||= []
+      end
+
+      # @private
+      def outputs
+        @outputs ||= []
+      end
+
+      # @private
+      def output_definitions
+        config.outputs.slice(*outputs)
+      end
+
+      # @private
+      def required_inputs
+        available_inputs
+          .reject { |_, input| input.optional }
+          .map { |_, input| input.name }
+      end
+
+      # @private
+      def missing_inputs(submitted_inputs)
+        submitted_inputs = [] if submitted_inputs.nil?
+
+        required_inputs.map(&:to_s) - submitted_inputs.map { |input| input[:name] }
+      end
+
+      # Define a particular order for inputs to be presented in the API/UI
+      # @example
+      #   group do
+      #     input :input1, :input2, :input3
+      #     input_order :input3, :input2, :input1
+      #   end
+      # @param new_input_order [Array<String,Symbol>]
+      # @return [Array<String, Symbol>]
+      def input_order(*new_input_order)
+        return @input_order = new_input_order if new_input_order.present?
+
+        @input_order ||= []
+      end
+
+      # @private
+      def order_available_inputs(original_inputs)
+        input_names = original_inputs.map { |_, input| input.name }.join(', ')
+
+        ordered_inputs =
+          input_order.each_with_object({}) do |input_name, inputs|
+            key, input = original_inputs.find { |_, input| input.name == input_name.to_s }
+            if input.nil?
+              Inferno::Application[:logger].error <<~ERROR
+                Error trying to order inputs in #{id}: #{title}:
+                - Unable to find input #{input_name} in available inputs: #{input_names}
+              ERROR
+              next
+            end
+            inputs[key] = original_inputs.delete(key)
+          end
+
+        original_inputs.each do |key, input|
+          ordered_inputs[key] = input
+        end
+
+        ordered_inputs
+      end
+
+      # @private
+      def all_outputs
+        outputs
+          .map { |output_identifier| config.output_name(output_identifier) }
+          .concat(children.flat_map(&:all_outputs))
+          .uniq
+      end
+
+      # @private
+      # Inputs available for this runnable's children. A running list of outputs
+      # created by the children is used to exclude any inputs which are provided
+      # by an earlier child's output.
+      def children_available_inputs
+        @children_available_inputs ||=
+          begin
+            child_outputs = []
+            children.each_with_object({}) do |child, definitions|
+              new_definitions = child.available_inputs.map(&:dup)
+              new_definitions.each do |input, new_definition|
+                existing_definition = definitions[input]
+
+                updated_definition =
+                  if existing_definition.present?
+                    existing_definition.merge_with_child(new_definition)
+                  else
+                    new_definition
+                  end
+
+                next if child_outputs.include?(updated_definition.name.to_sym)
+
+                definitions[updated_definition.name.to_sym] = updated_definition
+              end
+
+              child_outputs.concat(child.all_outputs).uniq!
+            end
+          end
+      end
+
+      # @private
+      # Inputs available for the user for this runnable and all its children.
+      def available_inputs
+        @available_inputs ||=
+          begin
+            available_inputs =
+              config.inputs
+                .slice(*inputs)
+                .each_with_object({}) do |(_, input), inputs|
+                  inputs[input.name.to_sym] = input
+                end
+
+            available_inputs.each do |input, current_definition|
+              child_definition = children_available_inputs[input]
+              current_definition.merge_with_child(child_definition)
+            end
+
+            available_inputs = children_available_inputs.merge(available_inputs)
+            order_available_inputs(available_inputs)
+          end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/runnable.rb

@@ -1,4 +1,5 @@
 require_relative 'configurable'
+require_relative 'input_output_handling'
 require_relative 'resume_test_route'
 require_relative '../utils/markdown_formatter'
 
@@ -20,6 +21,7 @@ module Inferno
       def self.extended(extending_class)
         super
         extending_class.extend Configurable
+        extending_class.extend InputOutputHandling
 
         extending_class.define_singleton_method(:inherited) do |subclass|
           copy_instance_variables(subclass)
@@ -39,28 +41,35 @@ module Inferno
 
       # Class instance variables are used to hold the metadata for Runnable
       # classes. When inheriting from a Runnable class, these class instance
-      # variables need to be copied. Any child Runnable classes will themselves
-      # need to be subclassed so that their parent can be updated.
+      # variables need to be copied. Some instance variables should not be
+      # copied, and will need to be repopulated from scratch on the new class.
+      # Any child Runnable classes will themselves need to be subclassed so that
+      # their parent can be updated.
+      VARIABLES_NOT_TO_COPY = [
+        :@id, # New runnable will have a different id
+        :@parent, # New runnable unlikely to have the same parent
+        :@children, # New subclasses have to be made for each child
+        :@test_count, # Needs to be recalculated
+        :@config, # Needs to be set by calling .config, which does extra work
+        :@available_inputs, # Needs to be recalculated
+        :@children_available_inputs # Needs to be recalculated
+      ].freeze
+
       # @private
       def copy_instance_variables(subclass)
-        instance_variables.each do |variable|
-          next if [:@id, :@groups, :@tests, :@parent, :@children, :@test_count, :@config].include?(variable)
-
-          subclass.instance_variable_set(variable, instance_variable_get(variable).dup)
-        end
+        instance_variables
+          .reject { |variable| VARIABLES_NOT_TO_COPY.include? variable }
+          .each { |variable| subclass.instance_variable_set(variable, instance_variable_get(variable).dup) }
 
         subclass.config(config)
 
-        child_types.each do |child_type|
-          new_children = send(child_type).map do |child|
-            Class.new(child).tap do |subclass_child|
-              subclass_child.parent = subclass
-            end
+        new_children = children.map do |child|
+          Class.new(child).tap do |subclass_child|
+            subclass_child.parent = subclass
           end
-
-          subclass.instance_variable_set(:"@#{child_type}", new_children)
-          subclass.children.concat(new_children)
         end
+
+        subclass.instance_variable_set(:@children, new_children)
       end
 
       # @private
@@ -253,36 +262,6 @@ module Inferno
         @input_instructions = format_markdown(new_input_instructions)
       end
 
-      # Define inputs
-      #
-      # @param identifier [Symbol] identifier for the input
-      # @param other_identifiers [Symbol] array of symbols if specifying multiple inputs
-      # @param input_definition [Hash] options for input such as type, description, or title
-      # @option input_definition [String] :title Human readable title for input
-      # @option input_definition [String] :description Description for the input
-      # @option input_definition [String] :type text | textarea | radio
-      # @option input_definition [String] :default The default value for the input
-      # @option input_definition [Boolean] :optional Set to true to not require input for test execution
-      # @option input_definition [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
-      # @return [void]
-      # @example
-      #   input :patient_id, title: 'Patient ID', description: 'The ID of the patient being searched for',
-      #                     default: 'default_patient_id'
-      # @example
-      #   input :textarea, title: 'Textarea Input Example', type: 'textarea', optional: true
-      def input(identifier, *other_identifiers, **input_definition)
-        if other_identifiers.present?
-          [identifier, *other_identifiers].compact.each do |input_identifier|
-            inputs << input_identifier
-            config.add_input(input_identifier)
-          end
-        else
-          inputs << identifier
-          config.add_input(identifier, input_definition)
-        end
-      end
-
       # Mark as optional. Tests are required by default.
       #
       # @param optional [Boolean]
@@ -317,62 +296,11 @@ module Inferno
         !optional?
       end
 
-      # Define outputs
-      #
-      # @param identifier [Symbol] identifier for the output
-      # @param other_identifiers [Symbol] array of symbols if specifying multiple outputs
-      # @param output_definition [Hash] options for output
-      # @option output_definition [String] :type text | textarea | oauth_credentials
-      # @return [void]
-      # @example
-      #   output :patient_id, :condition_id, :observation_id
-      # @example
-      #   output :oauth_credentials, type: 'oauth_credentials'
-      def output(identifier, *other_identifiers, **output_definition)
-        if other_identifiers.present?
-          [identifier, *other_identifiers].compact.each do |output_identifier|
-            outputs << output_identifier
-            config.add_output(output_identifier)
-          end
-        else
-          outputs << identifier
-          config.add_output(identifier, output_definition)
-        end
-      end
-
       # @private
       def default_id
         to_s
       end
 
-      # @private
-      def inputs
-        @inputs ||= []
-      end
-
-      # @private
-      def input_definitions
-        config.inputs.slice(*inputs)
-      end
-
-      # @private
-      def output_definitions
-        config.outputs.slice(*outputs)
-      end
-
-      # @private
-      def outputs
-        @outputs ||= []
-      end
-
-      # @private
-      def child_types
-        return [] if ancestors.include? Inferno::Entities::Test
-        return [:groups] if ancestors.include? Inferno::Entities::TestSuite
-
-        [:groups, :tests]
-      end
-
       # @private
       def children
         @children ||= []
@@ -454,49 +382,12 @@ module Inferno
         @test_count ||= children&.reduce(0) { |sum, child| sum + child.test_count } || 0
       end
 
-      # @private
-      def required_inputs(prior_outputs = [])
-        required_inputs =
-          inputs
-            .reject { |input| input_definitions[input][:optional] }
-            .map { |input| config.input_name(input) }
-            .reject { |input| prior_outputs.include?(input) }
-        children_required_inputs = children.flat_map { |child| child.required_inputs(prior_outputs) }
-        prior_outputs.concat(outputs.map { |output| config.output_name(output) })
-        (required_inputs + children_required_inputs).flatten.uniq
-      end
-
-      # @private
-      def missing_inputs(submitted_inputs)
-        submitted_inputs = [] if submitted_inputs.nil?
-
-        required_inputs.map(&:to_s) - submitted_inputs.map { |input| input[:name] }
-      end
-
       # @private
       def user_runnable?
         @user_runnable ||= parent.nil? ||
                            !parent.respond_to?(:run_as_group?) ||
                            (parent.user_runnable? && !parent.run_as_group?)
       end
-
-      # @private
-      def available_input_definitions(prior_outputs = [])
-        available_input_definitions =
-          inputs
-            .each_with_object({}) do |input, definitions|
-              definitions[config.input_name(input)] =
-                config.input_config(input)
-            end
-        available_input_definitions.reject! { |input, _| prior_outputs.include? input }
-
-        children_available_input_definitions =
-          children.each_with_object({}) do |child, definitions|
-            definitions.merge!(child.available_input_definitions(prior_outputs))
-          end
-        prior_outputs.concat(outputs.map { |output| config.output_name(output) })
-        children_available_input_definitions.merge(available_input_definitions)
-      end
     end
   end
 end