inferno_core 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b643b7c720a9c79df5f329a9947110971076db80fe29f0b57928230cf348d1b
-  data.tar.gz: e03d93994e7ad33e6e131969af5e31449390d36670d256a7d4bf43c1a9f80e4d
+  metadata.gz: 40769c54fd3854730eb080d1bb9e0755ff1551b00761968155d463dd3a6ce3e0
+  data.tar.gz: 8bbf5aaa2b09d7d5ff54e56a3ed33ce4e1f4df29fc53e3737f18e9972dc34f1e
 SHA512:
-  metadata.gz: 4767e5dfd7f469a6eb70892fb9e5402f2a46708655810b91be0b3d1d9d1dfa839c3502678156f763f5e9a7999948a31013fb68e3a1d1605306d5297639f3b3c3
-  data.tar.gz: 3adbce3ebb0786095826a114e4c6bc6a3ced2f9e560e2eaa6f6e6f6784bbf44c10ef25734f67bb097ee384b4cd6ab3296dc156e2c14cd5085bc64cb4fb27f575
+  metadata.gz: 35fe2518d3856f01b3358da68d862318784f05ab067b579d3ac62053dc1deed2be2895e3cfb5ff8efbc97e71d2495a11ebf66eadf23c5b8b4edb502707334838
+  data.tar.gz: 04e37af9daf40c01f0d4182f055e4ddf187d72f0e9d8a43e8858af5c549a4a60900d71f034a8e027e20f53a56f6b5e835bce1fca3a0b98870b07e0681793a2d9

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

@@ -5,7 +5,8 @@ module Inferno
         class Create < Controller
           include Import[
                     test_sessions_repo: 'repositories.test_sessions',
-                    session_data_repo: 'repositories.session_data'
+                    session_data_repo: 'repositories.session_data',
+                    test_runs_repo: 'repositories.test_runs'
                   ]
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
@@ -14,8 +15,18 @@ module Inferno
             test_session = test_sessions_repo.find(params[:test_session_id])
 
             # if testsession.nil?
+            if test_runs_repo.active_test_run_for_session?(test_session.id)
+              self.status = 409
+              self.body = { error: 'Cannot run new test while another test run is in progress' }.to_json
+              return
+            end
 
             test_run = repo.create(create_params(params).merge(status: 'queued'))
+            missing_inputs = test_run.runnable.missing_inputs(params[:inputs])
+
+            raise Inferno::Exceptions::RequiredInputsNotFound, missing_inputs if missing_inputs.any?
+            raise Inferno::Exceptions::NotUserRunnableException unless test_run.runnable.user_runnable?
+
             self.body = serialize(test_run)
 
             params[:inputs]&.each do |input|
@@ -27,7 +38,9 @@ module Inferno
             end
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
-          rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation => e
+          rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
+                 Inferno::Exceptions::RequiredInputsNotFound,
+                 Inferno::Exceptions::NotUserRunnableException => e
             self.body = { errors: e.message }.to_json
             self.status = 422
           rescue StandardError => e

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

@@ -0,0 +1,11 @@
+module Inferno
+  module Web
+    module Serializers
+      class HashValueExtractor < Blueprinter::Extractor
+        def extract(field_name, object, _local_options, _options)
+          object.send(field_name).values
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,10 @@ module Inferno
       class Test < Serializer
         identifier :id
         field :title
-        field :inputs
-        field :outputs do |test, _options|
-          test.outputs.map { |output| { name: output } }
-        end
+        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :output_definitions, name: :outputs, extractor: HashValueExtractor
         field :description
+        field :user_runnable?, name: :user_runnable
       end
     end
   end

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

@@ -4,18 +4,16 @@ module Inferno
       class TestGroup < Serializer
         identifier :id
 
-        # TODO: fill out test group
         field :title
         field :description
         field :test_count
-        # field :run_as_group
+        field :run_as_group?, name: :run_as_group
+        field :user_runnable?, name: :user_runnable
 
         association :groups, name: :test_groups, blueprint: TestGroup
         association :tests, blueprint: Test
-        field :inputs
-        field :outputs do |group, _options|
-          group.outputs.map { |input| { name: input } }
-        end
+        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :output_definitions, name: :outputs, extractor: HashValueExtractor
       end
     end
   end

data/lib/inferno/config/application.rb

@@ -9,6 +9,7 @@ module Inferno
 
     Application.register('js_host', ENV.fetch('JS_HOST', ''))
     Application.register('async_jobs', ENV['ASYNC_JOBS'] != 'false')
+    Application.register('inferno_host', ENV.fetch('INFERNO_HOST', 'http://localhost:4567'))
 
     configure do |config|
       config.root = File.expand_path('../../..', __dir__)

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

@@ -4,12 +4,10 @@ Inferno::Application.boot(:suites) do
 
     files_to_load = Dir.glob(File.join(Dir.pwd, 'lib', '*.rb'))
 
-    if ENV['LOAD_DEV_SUITES'] == 'true'
-      files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'dev_suites', '**', '*.rb'))
-    end
-
-    if ENV['LOAD_UI_SUITES'] == 'true'
-      files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'ui_suites', '**', '*.rb'))
+    if ENV['LOAD_DEV_SUITES'].present?
+      ENV['LOAD_DEV_SUITES'].split(',').map(&:strip).reject(&:empty?).each do |suite|
+        files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'dev_suites', suite, '**', '*.rb'))
+      end
     end
 
     if ENV['APP_ENV'] == 'test'

data/lib/inferno/dsl/assertions.rb

@@ -88,6 +88,26 @@ module Inferno
       rescue JSON::ParserError
         assert false, "Invalid JSON. #{message}"
       end
+
+      def assert_valid_http_uri(uri, message = '')
+        error_message = message || "\"#{uri}\" is not a valid URI"
+        assert uri =~ /\A#{URI::DEFAULT_PARSER.make_regexp(['http', 'https'])}\z/, error_message
+      end
+
+      def assert_response_content_type(type, request: self.request)
+        header = request.response_header('Content-Type')
+        assert header.present?, no_content_type_message
+
+        assert header.value.start_with?(type), bad_content_type_message(type, header.value)
+      end
+
+      def no_content_type_message
+        'Response did not contain a `Content-Type` header.'
+      end
+
+      def bad_content_type_message(expected, received)
+        "Expected `Content-Type` to be `#{expected}`, but found `#{received}`"
+      end
     end
   end
 end

data/lib/inferno/dsl/configurable.rb

@@ -0,0 +1,126 @@
+module Inferno
+  module DSL
+    # This module contains the DSL for managing runnable configuration.
+    module Configurable
+      def self.extended(klass)
+        klass.extend Forwardable
+        klass.def_delegator 'self.class', :config
+      end
+
+      def config(new_configuration = {})
+        @config ||= Configuration.new
+
+        return @config if new_configuration.blank?
+
+        @config.apply(new_configuration)
+      end
+
+      # @api private
+      class Configuration
+        attr_accessor :configuration
+
+        def initialize(configuration = {})
+          self.configuration = configuration
+        end
+
+        def apply(new_configuration)
+          config_to_apply =
+            if new_configuration.is_a? Configuration
+              new_configuration.configuration
+            else
+              new_configuration
+            end
+
+          self.configuration = configuration.deep_merge(config_to_apply)
+        end
+
+        def options
+          configuration[:options] ||= {}
+        end
+
+        ### Input Configuration ###
+
+        def inputs
+          configuration[:inputs] ||= {}
+        end
+
+        def add_input(identifier, new_config = {})
+          existing_config = input_config(identifier) || {}
+          inputs[identifier] = default_input_config(identifier).merge(existing_config, new_config)
+        end
+
+        def default_input_config(identifier)
+          { name: identifier, type: 'text' }
+        end
+
+        def input_config_exists?(identifier)
+          inputs.key? identifier
+        end
+
+        def input_config(identifier)
+          inputs[identifier]
+        end
+
+        def input_name(identifier)
+          inputs.dig(identifier, :name) || identifier
+        end
+
+        ### Output Configuration ###
+
+        def outputs
+          configuration[:outputs] ||= {}
+        end
+
+        def add_output(identifier)
+          return if output_config_exists?(identifier)
+
+          outputs[identifier] = default_output_config(identifier)
+        end
+
+        def default_output_config(identifier)
+          { name: identifier }
+        end
+
+        def output_config_exists?(identifier)
+          outputs.key? identifier
+        end
+
+        def output_config(identifier)
+          outputs[identifier]
+        end
+
+        def output_name(identifier)
+          outputs.dig(identifier, :name) || identifier
+        end
+
+        ### Request Configuration ###
+
+        def requests
+          configuration[:requests] ||= {}
+        end
+
+        def add_request(identifier)
+          return if request_config_exists?(identifier)
+
+          requests[identifier] = default_request_config(identifier)
+        end
+
+        def default_request_config(identifier)
+          { name: identifier }
+        end
+
+        def request_config_exists?(identifier)
+          requests.key? identifier
+        end
+
+        def request_config(identifier)
+          requests[identifier]
+        end
+
+        def request_name(identifier)
+          requests.dig(identifier, :name) || identifier
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_client.rb

@@ -69,12 +69,14 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
+      # @option options [Hash]  Input headers here - headers are optional and
+      #   must be entered as the last piece of input to this method
       # @return [Inferno::Entities::Request]
-      def fhir_operation(path, body: nil, client: :default, name: nil, **_options)
+      def fhir_operation(path, body: nil, client: :default, name: nil, **options)
         store_request('outgoing', name) do
           headers = fhir_client(client).fhir_headers
           headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
+          headers.merge!(options[:headers]) if options[:headers].present?
           fhir_client(client).send(:post, path, body, headers)
         end
       end

data/lib/inferno/dsl/http_client.rb

@@ -60,16 +60,17 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
+      # @option options [Hash] Input headers here - headers are optional and
+      #   must be entered as the last piece of input to this method
       # @return [Inferno::Entities::Request]
-      def get(url = '', client: :default, name: nil, **_options)
+      def get(url = '', client: :default, name: nil, **options)
         store_request('outgoing', name) do
           client = http_client(client)
 
           if client
-            client.get(url)
+            client.get(url, nil, options[:headers])
           elsif url.match?(%r{\Ahttps?://})
-            Faraday.get(url)
+            Faraday.get(url, nil, options[:headers])
           else
             raise StandardError, 'Must use an absolute url or define an HTTP client with a base url'
           end
@@ -85,16 +86,17 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
+      # @option options [Hash] Input headers here - headers are optional and
+      #   must be entered as the last piece of input to this method
       # @return [Inferno::Entities::Request]
-      def post(url = '', body: nil, client: :default, name: nil, **_options)
+      def post(url = '', body: nil, client: :default, name: nil, **options)
         store_request('outgoing', name) do
           client = http_client(client)
 
           if client
-            client.post(url, body)
+            client.post(url, body, options[:headers])
           elsif url.match?(%r{\Ahttps?://})
-            Faraday.post(url, body)
+            Faraday.post(url, body, options[:headers])
           else
             raise StandardError, 'Must use an absolute url or define an HTTP client with a base url'
           end

data/lib/inferno/dsl/request_storage.rb

@@ -38,13 +38,14 @@ module Inferno
 
       # TODO: do a check in the test runner
       def named_request(name)
-        requests.find { |request| request.name == name.to_sym }
+        requests.find { |request| request.name == self.class.config.request_name(name.to_sym) }
       end
 
       # @api private
       def store_request(direction, name = nil, &block)
         response = block.call
 
+        name = self.class.config.request_name(name)
         request =
           if response.is_a? FHIR::ClientReply
             Entities::Request.from_fhir_client_reply(
@@ -64,8 +65,9 @@ module Inferno
       def load_named_requests
         requests_repo = Inferno::Repositories::Requests.new
         self.class.named_requests_used.map do |request_name|
-          request = requests_repo.find_named_request(test_session_id, request_name)
-          raise StandardError, "Unable to find '#{request_name}' request" if request.nil?
+          request_alias = self.class.config.request_name(request_name)
+          request = requests_repo.find_named_request(test_session_id, request_alias)
+          raise StandardError, "Unable to find '#{request_alias}' request" if request.nil?
 
           requests << request
         end
@@ -84,16 +86,20 @@ module Inferno
 
         # Specify the named requests made by a test
         #
-        # @param *names [Symbol] one or more Symbols
-        def makes_request(*names)
-          named_requests_made.concat(names)
+        # @param *identifiers [Symbol] one or more Symbols
+        def makes_request(*identifiers)
+          named_requests_made.concat(identifiers).uniq!
+          identifiers.each do |identifier|
+            config.add_request(identifier)
+          end
         end
 
         # Specify the name for a request received by a test
         #
-        # @param *names [Symbol] one or more Symbols
-        def receives_request(name)
-          @incoming_request_name = name
+        # @param *identifiers [Symbol] one or more Symbols
+        def receives_request(identifier)
+          config.add_request(identifier)
+          @incoming_request_name = identifier
         end
 
         # @api private
@@ -103,9 +109,12 @@ module Inferno
 
         # Specify the named requests used by a test
         #
-        # @param *names [Symbol] one or more Symbols
-        def uses_request(*names)
-          named_requests_used.concat(names)
+        # @param *identifiers [Symbol] one or more Symbols
+        def uses_request(*identifiers)
+          named_requests_used.concat(identifiers).uniq!
+          identifiers.each do |identifier|
+            config.add_request(identifier)
+          end
         end
       end
     end

data/lib/inferno/dsl/resume_test_route.rb

@@ -48,7 +48,7 @@ module Inferno
           request.to_hash.merge(
             test_session_id: test_run.test_session_id,
             result_id: waiting_result.id,
-            name: test.incoming_request_name
+            name: test.config.request_name(test.incoming_request_name)
           )
         )
       end

data/lib/inferno/dsl/runnable.rb

@@ -1,4 +1,6 @@
+require_relative 'configurable'
 require_relative 'resume_test_route'
+require_relative '../utils/markdown_formatter'
 
 module Inferno
   module DSL
@@ -7,6 +9,8 @@ module Inferno
     module Runnable
       attr_accessor :parent
 
+      include Inferno::Utils::MarkdownFormatter
+
       # When a class (e.g. TestSuite/TestGroup) uses this module, set it up
       # so that subclassing it works correctly.
       # - add the subclass to the relevant repository when it is created
@@ -15,6 +19,7 @@ module Inferno
       # @api private
       def self.extended(extending_class)
         super
+        extending_class.extend Configurable
 
         extending_class.define_singleton_method(:inherited) do |subclass|
           copy_instance_variables(subclass)
@@ -39,11 +44,13 @@ module Inferno
       # @api private
       def copy_instance_variables(subclass)
         instance_variables.each do |variable|
-          next if [:@id, :@groups, :@tests, :@parent, :@children, :@test_count].include?(variable)
+          next if [:@id, :@groups, :@tests, :@parent, :@children, :@test_count, :@config].include?(variable)
 
           subclass.instance_variable_set(variable, instance_variable_get(variable).dup)
         end
 
+        subclass.config(config)
+
         child_types.each do |child_type|
           new_children = send(child_type).map do |child|
             Class.new(child).tap do |subclass_child|
@@ -126,16 +133,16 @@ module Inferno
 
       # @api private
       def configure_child_class(klass, hash_args) # rubocop:disable Metrics/CyclomaticComplexity
-        inputs.each do |input_definition|
-          next if klass.inputs.any? { |input| input[:name] == input_definition[:name] }
+        inputs.each do |name|
+          next if klass.inputs.any? { |klass_input_name| klass_input_name == name }
 
-          klass.input input_definition[:name], input_definition
+          klass.input name
         end
 
-        outputs.each do |output_definition|
-          next if klass.outputs.include? output_definition
+        outputs.each do |output_name|
+          next if klass.outputs.include? output_name
 
-          klass.output output_definition
+          klass.output output_name
         end
 
         new_fhir_client_definitions = klass.instance_variable_get(:@fhir_client_definitions) || {}
@@ -154,8 +161,14 @@ module Inferno
         end
         klass.instance_variable_set(:@http_client_definitions, new_http_client_definitions)
 
+        klass.config(config)
+
         hash_args.each do |key, value|
-          klass.send(key, *value)
+          if value.is_a? Array
+            klass.send(key, *value)
+          else
+            klass.send(key, value)
+          end
         end
 
         klass.children.each do |child_class|
@@ -193,43 +206,48 @@ module Inferno
       def description(new_description = nil)
         return @description if new_description.nil?
 
-        @description = new_description
+        @description = format_markdown(new_description)
       end
 
       # Define inputs
       #
-      # @param name [Symbol] name of the input
-      # @param other_names [Symbol] array of symbols if specifying multiple 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
       # @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
       # @return [void]
       # @example
       #   input :patientid, 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'
-      def input(name, *other_names, **input_definition)
-        if other_names.present?
-          [name, *other_names].each do |input_name|
-            inputs.push({ name: input_name, title: nil, description: nil, type: 'text' })
+      #   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
-          input_definition[:type] = 'text' unless input_definition.key? :type
-          inputs.push({ name: name }.merge(input_definition))
+          inputs << identifier
+          config.add_input(identifier, input_definition)
         end
       end
 
       # Define outputs
       #
-      # @param output_definitions [Symbol]
+      # @param output_lists [Symbol]
       # @return [void]
       # @example
       #   output :patient_id, :bearer_token
-      def output(*output_definitions)
-        outputs.concat(output_definitions)
+      def output(*output_list)
+        output_list.each do |output_identifier|
+          outputs << output_identifier
+          config.add_output(output_identifier)
+        end
       end
 
       # @api private
@@ -242,6 +260,14 @@ module Inferno
         @inputs ||= []
       end
 
+      def input_definitions
+        config.inputs.slice(*inputs)
+      end
+
+      def output_definitions
+        config.outputs.slice(*outputs)
+      end
+
       # @api private
       def outputs
         @outputs ||= []
@@ -334,6 +360,28 @@ module Inferno
       def test_count
         @test_count ||= children&.reduce(0) { |sum, child| sum + child.test_count } || 0
       end
+
+      def required_inputs(prior_outputs = [])
+        required_inputs = inputs.select do |input|
+          !input_definitions[input][:optional] && !prior_outputs.include?(input)
+        end
+        required_inputs.map! { |input_identifier| input_definitions[input_identifier][:name] }
+        children_required_inputs = children.flat_map { |child| child.required_inputs(prior_outputs) }
+        prior_outputs.concat(outputs)
+        (required_inputs + children_required_inputs).flatten.uniq
+      end
+
+      def missing_inputs(submitted_inputs)
+        submitted_inputs = [] if submitted_inputs.nil?
+
+        required_inputs.map(&:to_s) - submitted_inputs.map { |input| input[:name] }
+      end
+
+      def user_runnable?
+        @user_runnable ||= parent.nil? ||
+                           !parent.respond_to?(:run_as_group?) ||
+                           (parent.user_runnable? && !parent.run_as_group?)
+      end
     end
   end
 end

data/lib/inferno/entities/request.rb

@@ -46,7 +46,7 @@ module Inferno
       # @param name [String] the header name
       # @return [Inferno::Entities::RequestHeader, nil]
       def response_header(name)
-        response_headers.find { |header| header.name == name.downcase }
+        response_headers.find { |header| header.name.casecmp(name).zero? }
       end
 
       # Find a request header
@@ -54,7 +54,7 @@ module Inferno
       # @param name [String] the header name
       # @return [Inferno::Entities::RequestHeader, nil]
       def request_header(name)
-        request_headers.find { |header| header.name == name.downcase }
+        request_headers.find { |header| header.name.casecmp(name).zero? }
       end
 
       # All of the request headers