inferno_core 0.0.3 → 0.0.4

data/lib/inferno/dsl.rb

@@ -1,6 +1,5 @@
 require_relative 'dsl/assertions'
 require_relative 'dsl/fhir_client'
-require_relative 'dsl/fhir_manipulation'
 require_relative 'dsl/fhir_validation'
 require_relative 'dsl/http_client'
 require_relative 'dsl/results'
@@ -14,8 +13,7 @@ module Inferno
       FHIRClient,
       HTTPClient,
       Results,
-      FHIRValidation,
-      FHIRManipulation
+      FHIRValidation
     ].freeze
 
     EXTENDABLE_DSL_MODULES = [

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

@@ -89,6 +89,18 @@ module Inferno
           named_requests_made.concat(names)
         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
+        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

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.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,5 @@
+require_relative 'resume_test_route'
+
 module Inferno
   module DSL
     # This module contains the DSL for defining child entities in the test
@@ -37,7 +39,7 @@ 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].include?(variable)
 
           subclass.instance_variable_set(variable, instance_variable_get(variable).dup)
         end
@@ -125,9 +127,9 @@ 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
+          next if klass.inputs.any? { |input| input[:name] == input_definition[:name] }
 
-          klass.input input_definition
+          klass.input input_definition[:name], input_definition
         end
 
         outputs.each do |output_definition|
@@ -196,12 +198,28 @@ module Inferno
 
       # Define inputs
       #
-      # @param inputs [Symbol]
+      # @param name [Symbol] name of the input
+      # @param other_names [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
       # @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'
+      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' })
+          end
+        else
+          input_definition[:type] = 'text' unless input_definition.key? :type
+          inputs.push({ name: name }.merge(input_definition))
+        end
       end
 
       # Define outputs
@@ -229,6 +247,7 @@ module Inferno
         @outputs ||= []
       end
 
+      # @api private
       def child_types
         return [] if ancestors.include? Inferno::Entities::Test
         return [:groups] if ancestors.include? Inferno::Entities::TestSuite
@@ -236,6 +255,7 @@ module Inferno
         [:groups, :tests]
       end
 
+      # @api private
       def children
         @children ||= []
       end
@@ -245,6 +265,75 @@ 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
     end
   end
 end

data/lib/inferno/entities.rb

@@ -4,9 +4,9 @@ require_relative 'entities/header'
 require_relative 'entities/message'
 require_relative 'entities/request'
 require_relative 'entities/result'
+require_relative 'entities/session_data'
 require_relative 'entities/test'
 require_relative 'entities/test_group'
-require_relative 'entities/test_input'
 require_relative 'entities/test_run'
 require_relative 'entities/test_session'
 require_relative 'entities/test_suite'

data/lib/inferno/entities/header.rb

@@ -2,13 +2,13 @@ module Inferno
   module Entities
     # A `Header` represents an HTTP request/response header
     #
-    # @attr_reader [String] id of the header
-    # @attr_reader [String] request_id index of the HTTP request
-    # @attr_reader [String] name header name
-    # @attr_reader [String] value header value
-    # @attr_reader [String] type request/response
-    # @attr_reader [Time] created_at
-    # @attr_reader [Time] updated_at
+    # @attr_accessor [String] id of the header
+    # @attr_accessor [String] request_id index of the HTTP request
+    # @attr_accessor [String] name header name
+    # @attr_accessor [String] value header value
+    # @attr_accessor [String] type request/response
+    # @attr_accessor [Time] created_at
+    # @attr_accessor [Time] updated_at
     class Header < Entity
       ATTRIBUTES = [:id, :request_id, :name, :type, :value, :created_at, :updated_at].freeze
 

data/lib/inferno/entities/message.rb

@@ -2,12 +2,14 @@ module Inferno
   module Entities
     # A `Message` represents a message generated during a test.
     #
-    # @attr_reader [String] id of the message
-    # @attr_reader [String] index of the message. Used for ordering.
-    # @attr_reader [String] result_id
-    # @attr_reader [Inferno::Entities::Result] result
-    # @attr_reader [String] type
-    # @attr_reader [String] message
+    # @attr_accessor [String] id of the message
+    # @attr_accessor [String] index of the message. Used for ordering.
+    # @attr_accessor [String] result_id
+    # @attr_accessor [Inferno::Entities::Result] result
+    # @attr_accessor [String] type
+    # @attr_accessor [String] message
+    # @attr_accessor [Time] created_at
+    # @attr_accessor [Time] updated_at
     class Message < Entity
       ATTRIBUTES = [:id, :index, :message, :result_id, :result, :type, :created_at, :updated_at].freeze
       TYPES = ['error', 'warning', 'info'].freeze

data/lib/inferno/entities/request.rb

@@ -2,21 +2,21 @@ module Inferno
   module Entities
     # A `Request` represents a request and response issued during a test.
     #
-    # @attr_reader [String] id of the request
-    # @attr_reader [String] index of the request. Used for ordering.
-    # @attr_reader [String] verb http verb
-    # @attr_reader [String] url request url
-    # @attr_reader [String] direction incoming/outgoing
-    # @attr_reader [String] name name for the request
-    # @attr_reader [String] status http response status code
-    # @attr_reader [String] request_body body of the http request
-    # @attr_reader [String] response_body body of the http response
-    # @attr_reader [Array<Inferno::Entities::Header>] headers http
+    # @attr_accessor [String] id of the request
+    # @attr_accessor [String] index of the request. Used for ordering.
+    # @attr_accessor [String] verb http verb
+    # @attr_accessor [String] url request url
+    # @attr_accessor [String] direction incoming/outgoing
+    # @attr_accessor [String] name name for the request
+    # @attr_accessor [String] status http response status code
+    # @attr_accessor [String] request_body body of the http request
+    # @attr_accessor [String] response_body body of the http response
+    # @attr_accessor [Array<Inferno::Entities::Header>] headers http
     #   request/response headers
-    # @attr_reader [String] result_id id of the result for this request
-    # @attr_reader [String] test_session_id id of the test session for this request
-    # @attr_reader [Time] created_at creation timestamp
-    # @attr_reader [Time] updated_at update timestamp
+    # @attr_accessor [String] result_id id of the result for this request
+    # @attr_accessor [String] test_session_id id of the test session for this request
+    # @attr_accessor [Time] created_at creation timestamp
+    # @attr_accessor [Time] updated_at update timestamp
     class Request < Entity
       ATTRIBUTES = [
         :id, :index, :verb, :url, :direction, :name, :status,
@@ -36,6 +36,11 @@ module Inferno
         @headers = params[:headers]&.map { |header| header.is_a?(Hash) ? Header.new(header) : header } || []
       end
 
+      # @return [Hash<String, String>]
+      def query_parameters
+        Addressable::URI.parse(url).query_values || {}
+      end
+
       # Find a response header
       #
       # @param name [String] the header name
@@ -117,6 +122,27 @@ module Inferno
       end
 
       class << self
+        # @api private
+        def from_rack_env(env, name: nil)
+          rack_request = env['router.request'].rack_request
+          url = "#{rack_request.base_url}#{rack_request.path}"
+          url += "?#{rack_request.query_string}" if rack_request.query_string.present?
+          request_headers =
+            env
+              .select { |key, _| key.start_with? 'HTTP_' }
+              .transform_keys { |key| key.delete_prefix('HTTP_').tr('_', '-').downcase }
+              .map { |header_name, value| Header.new(name: header_name, value: value, type: 'request') }
+
+          new(
+            verb: rack_request.request_method.downcase,
+            url: url,
+            direction: 'incoming',
+            name: name,
+            request_body: rack_request.body.string,
+            headers: request_headers
+          )
+        end
+
         # @api private
         def from_http_response(response, test_session_id:, direction: 'outgoing', name: nil)
           request_headers =