inferno_core 0.0.2 → 0.0.6

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/fhir_client_builder.rb

@@ -14,6 +14,7 @@ module Inferno
         FHIR::Client.new(url).tap do |client|
           client.additional_headers = headers if headers
           client.default_json
+          client.set_bearer_token bearer_token if bearer_token
         end
       end
 
@@ -32,6 +33,21 @@ module Inferno
           end
       end
 
+      # Define the bearer token for a client. A string or symbol can be provided.
+      # A string is interpreted as a token. A symbol is interpreted as the name of
+      # an input to the Runnable.
+      #
+      # @param bearer_token [String, Symbol]
+      # @return [void]
+      def bearer_token(bearer_token = nil)
+        @bearer_token ||=
+          if bearer_token.is_a? Symbol
+            runnable.send(bearer_token)
+          else
+            bearer_token
+          end
+      end
+
       # Define custom headers for a client
       #
       # @param headers [Hash]

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,35 @@ 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 *identifiers [Symbol] one or more Symbols
+        def receives_request(identifier)
+          config.add_request(identifier)
+          @incoming_request_name = identifier
+        end
+
+        # @api private
+        def incoming_request_name
+          @incoming_request_name
         end
 
         # 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/results.rb

@@ -49,6 +49,55 @@ module Inferno
       def omit_if(test, message = '')
         raise Exceptions::OmitException, message if test
       end
+
+      # Halt execution of the current test and wait for execution to resume.
+      #
+      # @see Inferno::DSL::Runnable#resume_test_route
+      # @example
+      #   resume_test_route :get, '/launch' do
+      #     request.query_parameters['iss']
+      #   end
+      #
+      #   test do
+      #     input :issuer
+      #     receives_request :launch
+      #
+      #     run do
+      #       wait(
+      #         identifier: issuer,
+      #         message: "Wating to receive a request with an issuer of #{issuer}"
+      #       )
+      #     end
+      #   end
+      # @param identifier [String] An identifier which can uniquely identify
+      #   this test run based on an incoming request. This is necessary so that
+      #   the correct test run can be resumed.
+      # @param message [String]
+      # @param timeout [Integer] Number of seconds to wait for an incoming
+      #   request
+      def wait(identifier:, message: '', timeout: 300)
+        identifier(identifier)
+        wait_timeout(timeout)
+
+        raise Exceptions::WaitException, message
+      end
+
+      def identifier(identifier = nil)
+        @identifier ||= identifier
+      end
+
+      def wait_timeout(timeout = nil)
+        @wait_timeout ||= timeout
+      end
+
+      # Halt execution of the current test. This provided for testing purposes
+      # and should not be used in real tests.
+      #
+      # @param message [String]
+      # @api private
+      def cancel(message = '')
+        raise Exceptions::CancelException, message
+      end
     end
   end
 end

data/lib/inferno/dsl/resume_test_route.rb

@@ -0,0 +1,89 @@
+require 'hanami-controller'
+
+module Inferno
+  module DSL
+    # A base class for creating routes to resume test execution upon receiving
+    # an incoming request.
+    # @api private
+    # @see Inferno::DSL::Runnable#resume_test_route
+    class ResumeTestRoute
+      include Hanami::Action
+      include Import[
+                requests_repo: 'repositories.requests',
+                results_repo: 'repositories.results',
+                test_runs_repo: 'repositories.test_runs',
+                tests_repo: 'repositories.tests'
+              ]
+
+      def self.call(params)
+        new.call(params)
+      end
+
+      # The incoming request
+      #
+      # @return [Inferno::Entities::Request]
+      def request
+        @request ||= Inferno::Entities::Request.from_rack_env(@params.env)
+      end
+
+      # @api private
+      def test_run
+        @test_run ||=
+          test_runs_repo.find_latest_waiting_by_identifier(test_run_identifier)
+      end
+
+      # @api private
+      def waiting_result
+        @waiting_result ||= results_repo.find_waiting_result(test_run_id: test_run.id)
+      end
+
+      # @api private
+      def update_result
+        results_repo.pass_waiting_result(waiting_result.id)
+      end
+
+      # @api private
+      def persist_request
+        requests_repo.create(
+          request.to_hash.merge(
+            test_session_id: test_run.test_session_id,
+            result_id: waiting_result.id,
+            name: test.config.request_name(test.incoming_request_name)
+          )
+        )
+      end
+
+      # @api private
+      def redirect_route
+        "/test_sessions/#{test_run.test_session_id}##{waiting_group_id}"
+      end
+
+      # @api private
+      def test
+        @test ||= tests_repo.find(waiting_result.test_id)
+      end
+
+      # @api private
+      def waiting_group_id
+        test.parent.id
+      end
+
+      # @api private
+      def call(_params)
+        if test_run.nil?
+          status(500, "Unable to find test run with identifier '#{test_run_identifier}'.")
+          return
+        end
+
+        test_runs_repo.mark_as_no_longer_waiting(test_run.id)
+
+        update_result
+        persist_request
+
+        Jobs.perform(Jobs::ResumeTestRun, test_run.id)
+
+        redirect_to redirect_route
+      end
+    end
+  end
+end

data/lib/inferno/dsl/runnable.rb

@@ -1,3 +1,7 @@
+require_relative 'configurable'
+require_relative 'resume_test_route'
+require_relative '../utils/markdown_formatter'
+
 module Inferno
   module DSL
     # This module contains the DSL for defining child entities in the test
@@ -5,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
@@ -13,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)
@@ -37,11 +44,13 @@ module Inferno
       # @api private
       def copy_instance_variables(subclass)
         instance_variables.each do |variable|
-          next if [:@id, :@groups, :@tests, :@parent, :@children].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|
@@ -124,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.include? input_definition
+        inputs.each do |name|
+          next if klass.inputs.any? { |klass_input_name| klass_input_name == name }
 
-          klass.input 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) || {}
@@ -152,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|
@@ -191,27 +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 inputs [Symbol]
+      # @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 :patient_id, :bearer_token
-      def input(*input_definitions)
-        inputs.concat(input_definitions)
+      #   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', 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
 
       # 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
@@ -224,11 +260,20 @@ 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 ||= []
       end
 
+      # @api private
       def child_types
         return [] if ancestors.include? Inferno::Entities::Test
         return [:groups] if ancestors.include? Inferno::Entities::TestSuite
@@ -236,6 +281,7 @@ module Inferno
         [:groups, :tests]
       end
 
+      # @api private
       def children
         @children ||= []
       end
@@ -245,6 +291,97 @@ module Inferno
 
         @validator_url = url
       end
+
+      # @api private
+      def suite
+        return self if ancestors.include? Inferno::Entities::TestSuite
+
+        parent.suite
+      end
+
+      # Create a route which will resume a test run when a request is received
+      #
+      # @see Inferno::DSL::Results#wait
+      # @example
+      #   resume_test_route :get, '/launch' do
+      #     request.query_parameters['iss']
+      #   end
+      #
+      #   test do
+      #     input :issuer
+      #     receives_request :launch
+      #
+      #     run do
+      #       wait(
+      #         identifier: issuer,
+      #         message: "Wating to receive a request with an issuer of #{issuer}"
+      #       )
+      #     end
+      #   end
+      #
+      # @param method [Symbol] the HTTP request type (:get, :post, etc.) for the
+      #   incoming request
+      # @param path [String] the path for this request. The route will be served
+      #   with a prefix of `/custom/TEST_SUITE_ID` to prevent path conflicts.
+      #   [Any of the path options available in Hanami
+      #   Router](https://github.com/hanami/router/tree/f41001d4c3ee9e2d2c7bb142f74b43f8e1d3a265#a-beautiful-dsl)
+      #   can be used here.
+      # @yield This method takes a block which must return the identifier
+      #   defined when a test was set to wait for the test run that hit this
+      #   route. The block has access to the `request` method which returns a
+      #   {Inferno::DSL::Request} object with the information for the incoming
+      #   request.
+      def resume_test_route(method, path, &block)
+        route_class = Class.new(ResumeTestRoute) do
+          define_method(:test_run_identifier, &block)
+          define_method(:request_name, -> { options[:name] })
+        end
+
+        route(method, path, route_class)
+      end
+
+      # Create a route to handle a request
+      #
+      # @param method [Symbol] the HTTP request type (:get, :post, etc.) for the
+      #   incoming request. `:all` will accept all HTTP request types.
+      # @param path [String] the path for this request. The route will be served
+      #   with a prefix of `/custom/TEST_SUITE_ID` to prevent path conflicts.
+      #   [Any of the path options available in Hanami
+      #   Router](https://github.com/hanami/router/tree/f41001d4c3ee9e2d2c7bb142f74b43f8e1d3a265#a-beautiful-dsl)
+      #   can be used here.
+      # @param handler [#call] the route handler. This can be any Rack
+      #   compatible object (e.g. a `Proc` object, a [Sinatra
+      #   app](http://sinatrarb.com/)) as described in the [Hanami Router
+      #   documentation.](https://github.com/hanami/router/tree/f41001d4c3ee9e2d2c7bb142f74b43f8e1d3a265#mount-rack-applications)
+      def route(method, path, handler)
+        Inferno.routes << { method: method, path: path, handler: handler, suite: suite }
+      end
+
+      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