inferno_core 0.4.35 → 0.4.37.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30182f3e68640375fa7109325e45456b1a51017df274fa367e209d4fdef9a7de
-  data.tar.gz: 5c2a06c4171424120d8b0d760c8b295c8410ec2ba0b47473a5a14ae8c894faf6
+  metadata.gz: ccd64a44d96c18439d7d844bd6ec467d9eb0c23d5964b0928539fd70a0e806f0
+  data.tar.gz: b72e0ac46e7aca9d496fe23f6b89537c4a5c2054acc20690e089dc17d3d2528d
 SHA512:
-  metadata.gz: 62d86aba85c02d2a40bf46e01dc6b31d6b2d6bf91af05bf75f0c9d183dcdffbe854b196a5c21fd7512b59db19e06429dcd42a173e51c84ac8b3a537940a2e930
-  data.tar.gz: e13f07fa322182878878fabe04b293f33596733dc926381fcbfbf589fda5cef517aaabe2ab4107876f67188d554aec241de5354ce45f3d738f5106329f73721e
+  metadata.gz: 33d89c3291db6f4bfaf92b704eb13177b961e49b2b5c9c358661e062bde12f0eb00f5ab55e91945e089a7d2d83a13002926153c53b75b30b1a18926b69791496
+  data.tar.gz: b6878fd8a73f017dccf8f027ac1ddfb7811a122f287a55ea6fe393b7e4d5dd0f2885d4e55d1a540f6bd5ec723619af8c00bdb8d633fd3ce187f9dd0d63790a97

data/lib/inferno/apps/web/controllers/controller.rb

@@ -1,3 +1,5 @@
+require 'hanami/action/mime/request_mime_weight'
+
 module Inferno
   module Web
     module Controllers
@@ -11,12 +13,14 @@ module Inferno
 
           subclass.include Import[repo: "inferno.repositories.#{subclass.resource_name}"]
 
-          subclass.config.default_request_format = :json
-          subclass.config.default_response_format = :json
-
           subclass.define_method(:serialize) do |*args|
             Inferno::Web::Serializers.const_get(self.class.resource_class).render(*args)
           end
+
+          # Hanami Controller 2.0.0 removes the ability to set a default
+          # Content-Type response header, so set it manually if it hasn't been
+          # set.
+          subclass.after { |_req, res| res.format = :json if res.format == :all && res.body&.first&.first == '{' }
         end
 
         def self.resource_name

data/lib/inferno/apps/web/controllers/test_sessions/client_show.rb

@@ -3,8 +3,6 @@ module Inferno
     module Controllers
       module TestSessions
         class ClientShow < Controller
-          config.default_response_format = :html
-
           CLIENT_PAGE =
             ERB.new(
               File.read(
@@ -31,6 +29,7 @@ module Inferno
 
             halt 404 if test_suite.nil?
 
+            res.format = :html
             res.body = CLIENT_PAGE
           end
         end

data/lib/inferno/config/application.rb

@@ -1,6 +1,6 @@
 require 'active_support/all'
 require 'dotenv'
-require 'dry/system/container'
+require 'dry/system'
 require 'sequel'
 require_relative 'boot'
 
@@ -25,7 +25,7 @@ module Inferno
 
     configure do |config|
       config.root = File.expand_path('../../..', __dir__)
-      config.bootable_dirs = [File.join('lib', 'inferno', 'config', 'boot')]
+      config.provider_dirs = [File.join('lib', 'inferno', 'config', 'boot')]
       config.component_dirs.add 'lib'
     end
   end

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

@@ -1,9 +1,9 @@
 require 'sequel'
 require 'erb'
 
-Inferno::Application.boot(:db) do
-  init do
-    use :logging
+Inferno::Application.register_provider(:db) do
+  prepare do
+    target_container.start :logging
 
     require 'yaml'
 

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

@@ -1,5 +1,5 @@
-Inferno::Application.boot(:logging) do
-  init do
+Inferno::Application.register_provider(:logging) do
+  prepare do
     logger =
       if Inferno::Application.env == :test
         log_file_directory = File.join(Dir.pwd, 'tmp')

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

@@ -1,8 +1,8 @@
 require_relative '../../repositories/presets'
 
-Inferno::Application.boot(:presets) do
-  init do
-    use :suites
+Inferno::Application.register_provider(:presets) do
+  prepare do
+    target_container.start :suites
 
     files_to_load = Dir.glob(['config/presets/*.json', 'config/presets/*.json.erb'])
     files_to_load.map! { |path| File.realpath(path) }

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

@@ -1,7 +1,7 @@
 require 'sidekiq'
 
-Inferno::Application.boot(:sidekiq) do
-  init do
+Inferno::Application.register_provider(:sidekiq) do
+  prepare do
     if Inferno::Application['async_jobs']
       Sidekiq.configure_server do |config|
         config.redis = { url: ENV.fetch('REDIS_URL', 'redis://127.0.0.1:6379/0') }

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

@@ -1,10 +1,11 @@
-Inferno::Application.boot(:suites) do
-  init do
-    use :logging
+Inferno::Application.register_provider(:suites) do
+  prepare do
+    target_container.start :logging
 
     require 'inferno/entities/test'
     require 'inferno/entities/test_group'
     require 'inferno/entities/test_suite'
+    require 'inferno/entities/test_kit'
 
     files_to_load = Dir.glob(File.join(Dir.pwd, 'lib', '*.rb'))
 
@@ -18,13 +19,24 @@ Inferno::Application.boot(:suites) do
       files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'spec', 'fixtures', '**', '*.rb'))
     end
 
+    # Whenever the definition of a Runnable class ends, add it to the
+    # appropriate repository.
+    in_memory_entities_trace = TracePoint.trace(:end) do |trace|
+      if trace.self < Inferno::Entities::Test ||
+         trace.self < Inferno::Entities::TestGroup ||
+         trace.self < Inferno::Entities::TestSuite ||
+         trace.self < Inferno::Entities::TestKit
+        trace.self.add_self_to_repository
+      end
+    end
+
     files_to_load.map! { |path| File.realpath(path) }
 
     files_to_load.each do |path|
       require_relative path
     end
 
-    ObjectSpace.each_object(TracePoint, &:disable)
+    in_memory_entities_trace.disable
 
     Inferno::Entities::TestSuite.descendants.each do |descendant|
       # When ID not assigned in custom test suites, Runnable.id will return default ID

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

@@ -1,6 +1,6 @@
-Inferno::Application.boot(:validator) do
-  init do
-    use :suites
+Inferno::Application.register_provider(:validator) do
+  prepare do
+    target_container.start :suites
 
     # This process should only run once, to start one job per validator,
     # so skipping it on workers will start it only once from the "web" process

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

@@ -1,5 +1,5 @@
-Inferno::Application.boot(:web) do |_app|
-  init do
+Inferno::Application.register_provider(:web) do |_app|
+  prepare do
     require 'blueprinter'
     require 'hanami/router'
     require 'hanami/controller'

data/lib/inferno/dsl/runnable.rb

@@ -26,17 +26,6 @@ module Inferno
 
         extending_class.define_singleton_method(:inherited) do |subclass|
           copy_instance_variables(subclass)
-
-          # Whenever the definition of a Runnable class ends, keep track of the
-          # file it came from. Once the Suite loader successfully loads a file,
-          # it will add all of the Runnable classes from that file to the
-          # appropriate repositories.
-          TracePoint.trace(:end) do |trace|
-            if trace.self == subclass
-              subclass.add_self_to_repository
-              trace.disable
-            end
-          end
         end
       end
 
@@ -360,6 +349,24 @@ module Inferno
         route(method, path, route_class)
       end
 
+      # Create an endpoint to receive incoming requests during a Test Run.
+      #
+      # @see Inferno::DSL::SuiteEndpoint
+      # @example
+      #  suite_endpoint :post, '/my_suite_endpoint', MySuiteEndpoint
+      # @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.
+      # @param [Class] a subclass of Inferno::DSL::SuiteEndpoint
+      # @return [void]
+      def suite_endpoint(method, path, endpoint_class)
+        route(method, path, endpoint_class)
+      end
+
       # Create a route to handle a request
       #
       # @param method [Symbol] the HTTP request type (:get, :post, etc.) for the

data/lib/inferno/dsl/suite_endpoint.rb

@@ -0,0 +1,330 @@
+require 'hanami/controller'
+require 'rack/request'
+require_relative '../ext/rack'
+
+module Inferno
+  module DSL
+    # A base class for creating endpoints to test client requests. This class is
+    # based on Hanami::Action, and may be used similarly to [a normal Hanami
+    # endpoint](https://github.com/hanami/controller/tree/v2.0.0).
+    #
+    # @example
+    # class AuthorizedEndpoint < Inferno::DSL::SuiteEndpoint
+    #   # Identify the incoming request based on a bearer token
+    #   def test_run_identifier
+    #     request.header['authorization']&.delete_prefix('Bearer ')
+    #   end
+    #
+    #   # Return a json FHIR Patient resource
+    #   def make_response
+    #     response.status = 200
+    #     response.body = FHIR::Patient.new(id: 'abcdef').to_json
+    #     response.format = :json
+    #   end
+    #
+    #   # Update the waiting test to pass when the incoming request is received.
+    #   # This will resume the test run.
+    #   def update_result
+    #     results_repo.update(result.id, result: 'pass')
+    #   end
+    #
+    #   # Apply the 'authorized' tag to the incoming request so that it may be
+    #   # used by later tests.
+    #   def tags
+    #     ['authorized']
+    #   end
+    # end
+    #
+    # class AuthorizedRequestSuite < Inferno::TestSuite
+    #   id :authorized_suite
+    #   suite_endpoint :get, '/authorized_endpoint', AuthorizedEndpoint
+    #
+    #   group do
+    #     title 'Authorized Request Group'
+    #
+    #     test do
+    #       title 'Wait for authorized request'
+    #
+    #       input :bearer_token
+    #
+    #       run do
+    #         wait(
+    #           identifier: bearer_token,
+    #           message: "Waiting to receive a request with bearer_token: #{bearer_token}" \
+    #                    "at `#{Inferno::Application['base_url']}/custom/authorized_suite/authorized_endpoint`"
+    #         )
+    #       end
+    #     end
+    #   end
+    # end
+    class SuiteEndpoint < Hanami::Action
+      attr_reader :req, :res
+
+      # @!group Overrides These methods should be overridden by subclasses to
+      #   define the behavior of the endpoint
+
+      # Override this method to determine a test run's identifier based on an
+      # incoming request.
+      #
+      # @return [String]
+      #
+      # @example
+      # def test_run_identifier
+      #   # Identify the test session of an incoming request based on the bearer
+      #   # token
+      #   request.headers['authorization']&.delete_prefix('Bearer ')
+      # end
+      def test_run_identifier
+        nil
+      end
+
+      # Override this method to build the response.
+      #
+      # @return [Void]
+      #
+      # @example
+      # def make_response
+      #   response.status = 200
+      #   response.body = { abc: 123 }.to_json
+      #   response.format = :json
+      # end
+      def make_response
+        nil
+      end
+
+      # Override this method to define the tags which will be applied to the
+      # request.
+      #
+      # @return [Array<String>]
+      def tags
+        @tags ||= []
+      end
+
+      # Override this method to assign a name to the request
+      #
+      # @return [String]
+      def name
+        result&.runnable&.incoming_request_name
+      end
+
+      # Override this method to update the current waiting result. To resume the
+      # test run, set the result to something other than 'waiting'.
+      #
+      # @return [Void]
+      #
+      # @example
+      # def update_result
+      #   results_repo.update(result.id, result: 'pass')
+      # end
+      def update_result
+        nil
+      end
+
+      # Override this method to specify whether this request should be
+      # persisted. Defaults to true.
+      #
+      # @return [Boolean]
+      def persist_request?
+        true
+      end
+
+      # @!endgroup
+
+      # @private
+      def self.call(...)
+        new.call(...)
+      end
+
+      # @return [Inferno::Repositories::Requests]
+      def requests_repo
+        @requests_repo ||= Inferno::Repositories::Requests.new
+      end
+
+      # @return [Inferno::Repositories::Results]
+      def results_repo
+        @results_repo ||= Inferno::Repositories::Results.new
+      end
+
+      # @return [Inferno::Repositories::TestRuns]
+      def test_runs_repo
+        @test_runs_repo ||= Inferno::Repositories::TestRuns.new
+      end
+
+      # @return [Inferno::Repositories::Tests]
+      def tests_repo
+        @tests_repo ||= Inferno::Repositories::Tests.new
+      end
+
+      # @private
+      def initialize(config: self.class.config) # rubocop:disable Lint/MissingSuper
+        @config = config
+      end
+
+      # The incoming request as a `Hanami::Action::Request`
+      #
+      # @return [Hanami::Action::Request]
+      #
+      # @example
+      # request.params               # Get url/query params
+      # request.body.read            # Get body
+      # request.headers['accept']    # Get Accept header
+      def request
+        req
+      end
+
+      # The response as a `Hanami::Action::Response`. Modify this to build the
+      # response to the incoming request.
+      #
+      # @return [Hanami::Action::Response]
+      #
+      # @example
+      # response.status = 200        # Set the status
+      # response.body = 'Ok'         # Set the body
+      # # Set headers
+      # response.headers.merge!('X-Custom-Header' => 'CUSTOM_HEADER_VALUE')
+      def response
+        res
+      end
+
+      # The test run which is waiting for incoming requests
+      #
+      # @return [Inferno::Entities::TestRun]
+      def test_run
+        @test_run ||=
+          test_runs_repo.find_latest_waiting_by_identifier(find_test_run_identifier).tap do |test_run|
+            halt 500, "Unable to find test run with identifier '#{test_run_identifier}'." if test_run.nil?
+          end
+      end
+
+      # The result which is waiting for incoming requests for the current test
+      # run
+      #
+      # @return [Inferno::Entities::Result]
+      def result
+        @result ||= find_result
+      end
+
+      # The test which is currently waiting for incoming requests
+      #
+      # @return [Inferno::Entities::Test]
+      def test
+        @test ||= tests_repo.find(result.test_id)
+      end
+
+      # @return [Logger] Inferno's logger
+      def logger
+        @logger ||= Application['logger']
+      end
+
+      # @private
+      def find_test_run_identifier
+        @test_run_identifier ||= test_run_identifier
+      rescue StandardError => e
+        halt 500, "Unable to determine test run identifier:\n#{e.full_message}"
+      end
+
+      # @private
+      def find_result
+        results_repo.find_waiting_result(test_run_id: test_run.id)
+      end
+
+      # @private
+      # The actual persisting happens in
+      # Inferno::Utils::Middleware::RequestRecorder, which allows the response
+      # to include response headers added by other parts of the rack stack
+      # rather than only the response headers explicitly added in the endpoint.
+      def persist_request
+        req.env['inferno.test_session_id'] = test_run.test_session_id
+        req.env['inferno.result_id'] = result.id
+        req.env['inferno.tags'] = tags
+        req.env['inferno.name'] = name if name.present?
+
+        add_persistence_callback
+      end
+
+      # @private
+      def resume_test_run?
+        find_result&.result != 'waiting'
+      end
+
+      # @private
+      # Inferno::Utils::Middleware::RequestRecorder actually resumes the
+      # TestRun. If it were resumed here, it would be resuming prior to the
+      # Request being persisted.
+      def resume
+        req.env['inferno.resume_test_run'] = true
+        req.env['inferno.test_run_id'] = test_run.id
+      end
+
+      # @private
+      def handle(req, res)
+        @req = req
+        @res = res
+        test_run
+
+        persist_request if persist_request?
+
+        update_result
+
+        resume if resume_test_run?
+
+        make_response
+      rescue StandardError => e
+        halt 500, e.full_message
+      end
+
+      # @private
+      def add_persistence_callback # rubocop:disable Metrics/CyclomaticComplexity
+        logger = Application['logger']
+        env = req.env
+        env['rack.after_reply'] ||= []
+        env['rack.after_reply'] << proc do
+          repo = Inferno::Repositories::Requests.new
+
+          uri = URI('http://example.com')
+          uri.scheme = env['rack.url_scheme']
+          uri.host = env['SERVER_NAME']
+          uri.port = env['SERVER_PORT']
+          uri.path = env['REQUEST_PATH'] || ''
+          uri.query = env['rack.request.query_string'] if env['rack.request.query_string'].present?
+          url = uri&.to_s
+          verb = env['REQUEST_METHOD']
+          logger.info('get body')
+          request_body = env['rack.input']
+          request_body.rewind if env['rack.input'].respond_to? :rewind
+          request_body = request_body.instance_of?(Puma::NullIO) ? nil : request_body.string
+
+          request_headers = ::Rack::Request.new(env).headers.to_h.map { |name, value| { name:, value: } }
+
+          status, response_headers, response_body = env['inferno.response']
+
+          response_headers = response_headers.map { |name, value| { name:, value: } }
+
+          repo.create(
+            verb:,
+            url:,
+            direction: 'incoming',
+            name: env['inferno.name'],
+            status:,
+            request_body:,
+            response_body: response_body.join,
+            result_id: env['inferno.result_id'],
+            test_session_id: env['inferno.test_session_id'],
+            request_headers:,
+            response_headers:,
+            tags: env['inferno.tags']
+          )
+
+          if env['inferno.resume_test_run']
+            test_run_id = env['inferno.test_run_id']
+            Inferno::Repositories::TestRuns.new.mark_as_no_longer_waiting(test_run_id)
+
+            Inferno::Jobs.perform(Jobs::ResumeTestRun, test_run_id)
+          end
+        rescue StandardError => e
+          logger.error(e.full_message)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl.rb

@@ -5,6 +5,7 @@ require_relative 'dsl/fhir_resource_validation'
 require_relative 'dsl/http_client'
 require_relative 'dsl/results'
 require_relative 'dsl/runnable'
+require_relative 'dsl/suite_endpoint'
 
 module Inferno
   # The DSL for writing tests.