inferno_core 0.3.12 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9bc9822a032ed4fa7c3b1639b24bc14c6ed977e271e60e424f6a1d60fbff657
-  data.tar.gz: 5d0a9a794ce081c3128e68d7cb6a1802a05aafddbcbb03ab7ee7667696ac81f5
+  metadata.gz: 987a2db725cb3b2517f392d2e566614f3e5fcd454f27164e6de64ec615b5661c
+  data.tar.gz: 1cce12a803e20d288e72f9f3b1dfd1def94f9cbe1fcb73f4c862f1063c3d5c8c
 SHA512:
-  metadata.gz: 8645e64fc2c5890378d9693734ce5268b219541c82307b13d14703f7a8e8ff70ddac9c00ddf254ba9db6121bb54015445222e497b0d519b9bc2de1d93ac1c06c
-  data.tar.gz: 67a64df05660cca2377009e45c13fb6baddae3cd39e3527d7fe85e6b64fc201b2cb871b894bf86c55ca6facc6f3790993e6548dec14ad245b563d8bbc5ac690f
+  metadata.gz: 646f385e975efc9eb957aa707934e7c3e04977c97bd73dae4a21a8dbfd60869c1662f1832bfac1a38cb534ed18ebc93d771937a8978a7fb5dba7e0b3db54b974
+  data.tar.gz: 106dc72ddaaba5f02be715aef376984adb7c97ae71c62668d45da094bcfe430ee1a7c5d940c99e92bfc645bc31c8bb2013406aaffb2a072fc1d0fc9771a3187f

data/lib/inferno/apps/web/application.rb

@@ -1,4 +1,5 @@
 require 'hanami/middleware/body_parser'
+require_relative 'router'
 
 module Inferno
   module Web

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

@@ -1,20 +1,18 @@
 module Inferno
   module Web
     module Controllers
-      class Controller
-        # Ensure that each request gets a new instance of the controller.
-        def self.call(params)
-          new.call(params)
+      class Controller < Hanami::Action
+        def self.call(...)
+          new.call(...)
         end
 
         def self.inherited(subclass)
           super
 
-          # This does some sort of magic that requires it be included in the
-          # subclass rather than superclass.
-          subclass.include Hanami::Action
+          subclass.include Import[repo: "inferno.repositories.#{subclass.resource_name}"]
 
-          subclass.include Import[repo: "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)

data/lib/inferno/apps/web/controllers/requests/show.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module Requests
         class Show < Controller
-          def call(params)
-            request = repo.find_full_request(params[:id])
+          def handle(req, res)
+            request = repo.find_full_request(req.params[:id])
             halt 404 if request.nil?
 
-            self.body = serialize(request, view: :full)
+            res.body = serialize(request, view: :full)
           end
         end
       end

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

@@ -4,9 +4,9 @@ module Inferno
       module TestRuns
         class Create < Controller
           include Import[
-                    test_sessions_repo: 'repositories.test_sessions',
-                    session_data_repo: 'repositories.session_data',
-                    test_runs_repo: 'repositories.test_runs'
+                    test_sessions_repo: 'inferno.repositories.test_sessions',
+                    session_data_repo: 'inferno.repositories.session_data',
+                    test_runs_repo: 'inferno.repositories.test_runs'
                   ]
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
@@ -42,38 +42,34 @@ module Inferno
             end
           end
 
-          def call(params)
-            test_session = test_sessions_repo.find(params[:test_session_id])
+          def handle(req, res)
+            test_session = test_sessions_repo.find(req.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
+              halt 409, { error: 'Cannot run new test while another test run is in progress' }.to_json
             end
 
             verify_runnable(
-              repo.build_entity(create_params(params)).runnable,
-              params[:inputs],
+              repo.build_entity(create_params(req.params)).runnable,
+              req.params[:inputs],
               test_session.suite_options
             )
 
-            test_run = repo.create(create_params(params).merge(status: 'queued'))
+            test_run = repo.create(create_params(req.params).merge(status: 'queued'))
 
-            self.body = serialize(test_run, suite_options: test_session.suite_options)
+            res.body = serialize(test_run, suite_options: test_session.suite_options)
 
-            persist_inputs(params, test_run)
+            persist_inputs(req.params, test_run)
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
                  Inferno::Exceptions::RequiredInputsNotFound,
                  Inferno::Exceptions::NotUserRunnableException => e
-            self.body = { errors: e.message }.to_json
-            self.status = 422
+            halt 422, { errors: e.message }.to_json
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
 
           def create_params(params)

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

@@ -4,21 +4,20 @@ module Inferno
       module TestRuns
         class Destroy < Controller
           include Import[
-                    test_runs_repo: 'repositories.test_runs',
-                    results_repo: 'repositories.results'
+                    test_runs_repo: 'inferno.repositories.test_runs',
+                    results_repo: 'inferno.repositories.results'
                   ]
 
-          def call(params)
-            test_run = test_runs_repo.find(params[:id])
+          def handle(req, res)
+            test_run = test_runs_repo.find(req.params[:id])
 
             if test_run.nil? || ['done', 'cancelling'].include?(test_run.status)
               # If it doesn't exist, already finished, or currently being cancelled
-              self.status = 204
-              return
+              halt 204
             end
 
             test_run_is_waiting = (test_run.status == 'waiting')
-            test_runs_repo.mark_as_cancelling(params[:id])
+            test_runs_repo.mark_as_cancelling(req.params[:id])
 
             if test_run_is_waiting
               waiting_result = results_repo.find_waiting_result(test_run_id: test_run.id)
@@ -26,11 +25,10 @@ module Inferno
               Jobs.perform(Jobs::ResumeTestRun, test_run.id)
             end
 
-            self.status = 204
+            res.status = 204
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_runs/results/index.rb

@@ -4,11 +4,11 @@ module Inferno
       module TestRuns
         module Results
           class Index < Controller
-            include Import[test_runs_repo: 'repositories.test_runs']
+            include Import[test_runs_repo: 'inferno.repositories.test_runs']
 
-            def call(params)
-              results = test_runs_repo.results_for_test_run(params[:test_run_id])
-              self.body = serialize(results)
+            def handle(req, res)
+              results = test_runs_repo.results_for_test_run(req.params[:test_run_id])
+              res.body = serialize(results)
             end
           end
         end

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

@@ -1,26 +1,28 @@
+require_relative '../../serializers/test_run'
+
 module Inferno
   module Web
     module Controllers
       module TestRuns
         class Show < Controller
-          include Import[test_sessions_repo: 'repositories.test_sessions']
+          include Import[test_sessions_repo: 'inferno.repositories.test_sessions']
 
-          def call(params)
-            test_run = repo.find(params[:id])
+          def handle(req, res)
+            test_run = repo.find(req.params[:id])
             halt 404 if test_run.nil?
 
-            if params[:include_results] == 'true'
+            if req.params[:include_results] == 'true'
               results_repo = Inferno::Repositories::Results.new
               test_run.results =
-                if params[:after].present?
-                  results_repo.test_run_results_after(test_run_id: test_run.id, after: Time.parse(params[:after]))
+                if req.params[:after].present?
+                  results_repo.test_run_results_after(test_run_id: test_run.id, after: Time.parse(req.params[:after]))
                 else
                   repo.results_for_test_run(test_run.id)
                 end
             end
 
             test_session = test_sessions_repo.find(test_run.test_session_id)
-            self.body = serialize(test_run, suite_options: test_session.suite_options)
+            res.body = serialize(test_run, suite_options: test_session.suite_options)
           end
         end
       end

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

@@ -1,3 +1,6 @@
+require_relative '../controller'
+require_relative '../../serializers/test_session'
+
 module Inferno
   module Web
     module Controllers
@@ -5,22 +8,20 @@ module Inferno
         class Create < Controller
           PARAMS = [:test_suite_id, :suite_options].freeze
 
-          def call(raw_params)
-            params = raw_params.to_h
-            params.merge!(JSON.parse(request.body.string).symbolize_keys) unless request.body.string.blank?
+          def handle(req, res)
+            params = req.params.to_h
+            params.merge!(JSON.parse(req.body.string).symbolize_keys) unless req.body.string.blank?
 
             session = repo.create(create_params(params))
 
             repo.apply_preset(session.id, params[:preset_id]) if params[:preset_id].present?
 
-            self.body = serialize(session)
+            res.body = serialize(session)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation => e
-            self.body = { errors: e.message }.to_json
-            self.status = 422
+            halt 422, { errors: e.message }.to_json
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
 
           def create_params(params)

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

@@ -3,12 +3,12 @@ module Inferno
     module Controllers
       module TestSessions
         class LastTestRun < Controller
-          include Import[test_runs_repo: 'repositories.test_runs']
+          include Import[test_runs_repo: 'inferno.repositories.test_runs']
 
-          def call(params)
-            test_run = test_runs_repo.last_test_run(params[:test_session_id])
+          def handle(req, res)
+            test_run = test_runs_repo.last_test_run(req.params[:id])
 
-            self.body =
+            res.body =
               if test_run.nil?
                 nil
               else

data/lib/inferno/apps/web/controllers/test_sessions/results/index.rb

@@ -4,14 +4,14 @@ module Inferno
       module TestSessions
         module Results
           class Index < Controller
-            include Import[test_sessions_repo: 'repositories.test_sessions']
+            include Import[test_sessions_repo: 'inferno.repositories.test_sessions']
 
-            def call(params)
-              self.body =
-                if params[:all] == 'true'
-                  serialize(test_sessions_repo.results_for_test_session(params[:test_session_id]))
+            def handle(req, res)
+              res.body =
+                if req.params[:all] == 'true'
+                  serialize(test_sessions_repo.results_for_test_session(req.params[:id]))
                 else
-                  serialize(repo.current_results_for_test_session(params[:test_session_id]))
+                  serialize(repo.current_results_for_test_session(req.params[:id]))
                 end
             end
           end

data/lib/inferno/apps/web/controllers/test_sessions/session_data/apply_preset.rb

@@ -1,3 +1,5 @@
+require_relative '../../controller'
+
 module Inferno
   module Web
     module Controllers
@@ -5,35 +7,33 @@ module Inferno
         module SessionData
           class ApplyPreset < Controller
             include Import[
-                      test_sessions_repo: 'repositories.test_sessions',
-                      presets_repo: 'repositories.presets'
+                      test_sessions_repo: 'inferno.repositories.test_sessions',
+                      presets_repo: 'inferno.repositories.presets'
                     ]
 
             def self.resource_class
               'SessionData'
             end
 
-            def call(params)
-              test_session_id = params[:test_session_id]
+            def handle(req, res)
+              test_session_id = req.params[:id]
               test_session = test_sessions_repo.find(test_session_id)
 
               if test_session.nil?
                 Application[:logger].error("Unknown test session #{test_session_id}")
-                self.status = 404
-                return
+                halt 404
               end
 
-              preset_id = params[:preset_id]
+              preset_id = req.params[:preset_id]
               preset = presets_repo.find(preset_id)
 
               if preset.nil?
                 Application[:logger].error("Unknown preset #{preset_id}")
-                self.status = 404
-                return
+                halt 404
               end
 
               test_sessions_repo.apply_preset(test_session_id, preset_id)
-              self.status = 200
+              res.status = 200
             end
           end
         end

data/lib/inferno/apps/web/controllers/test_sessions/session_data/index.rb

@@ -1,17 +1,19 @@
+require_relative '../../../serializers/session_data'
+
 module Inferno
   module Web
     module Controllers
       module TestSessions
         module SessionData
           class Index < Controller
-            include Import[session_data_repo: 'repositories.session_data']
+            include Import[session_data_repo: 'inferno.repositories.session_data']
 
             def self.resource_class
               'SessionData'
             end
 
-            def call(params)
-              self.body = serialize(session_data_repo.get_all_from_session(params[:test_session_id]))
+            def handle(req, res)
+              res.body = serialize(session_data_repo.get_all_from_session(req.params[:id]))
             end
           end
         end

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

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSessions
         class Show < Controller
-          def call(params)
-            test_session = repo.find(params[:id])
+          def handle(req, res)
+            test_session = repo.find(req.params[:id])
             halt 404 if test_session.nil?
 
-            self.body = serialize(test_session)
+            res.body = serialize(test_session)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_suites/check_configuration.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSuites
         class CheckConfiguration < Controller
-          def call(params)
-            test_suite = repo.find(params[:id])
+          def handle(req, res)
+            test_suite = repo.find(req.params[:id])
             halt 404 if test_suite.nil?
 
-            self.body =
+            res.body =
               Inferno::Web::Serializers::Message.render(test_suite.configuration_messages(force_recheck: true))
           end
         end

data/lib/inferno/apps/web/controllers/test_suites/index.rb

@@ -3,8 +3,8 @@ module Inferno
     module Controllers
       module TestSuites
         class Index < Controller
-          def call(_params)
-            self.body = serialize(repo.all, view: :summary)
+          def handle(_req, res)
+            res.body = serialize(repo.all, view: :summary)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_suites/show.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSuites
         class Show < Controller
-          def call(params)
-            test_suite = repo.find(params[:id])
+          def handle(req, res)
+            test_suite = repo.find(req.params[:id])
             halt 404 if test_suite.nil?
 
-            self.body = serialize(test_suite, view: :full)
+            res.body = serialize(test_suite, view: :full)
           end
         end
       end

data/lib/inferno/apps/web/router.rb

@@ -1,62 +1,76 @@
 require 'erb'
 
+Dir.glob(File.join(__dir__, 'controllers', '**', '*.rb')).each { |path| require_relative path }
+
 module Inferno
   module Web
     client_page = ERB.new(File.read(File.join(Inferno::Application.root, 'lib', 'inferno', 'apps', 'web',
                                               'index.html.erb'))).result
 
-    Router = Hanami::Router.new(namespace: Inferno::Web::Controllers) do
-      namespace Application['base_path'] do
-        namespace 'api' do
-          resources 'test_runs', only: [:create, :show, :destroy] do
-            resources 'results', only: [:index]
-          end
-
-          resources 'test_sessions', only: [:create, :show] do
-            resources 'results', only: [:index]
-            resources 'session_data', only: [:index] do
-              collection do
-                put '/apply_preset',
-                    to: Inferno::Web::Controllers::TestSessions::SessionData::ApplyPreset,
-                    as: :apply_preset
-              end
-            end
-          end
-          get 'test_sessions/:test_session_id/last_test_run',
+    base_path = Application['base_path']
+    base_path = "/#{base_path.delete_prefix('/')}" if base_path.present?
+
+    Router = Hanami::Router.new(prefix: base_path) do
+      scope 'api' do
+        scope 'test_runs' do
+          post '/', to: Inferno::Web::Controllers::TestRuns::Create, as: :create
+          get '/:id', to: Inferno::Web::Controllers::TestRuns::Show, as: :show
+          delete '/:id', to: Inferno::Web::Controllers::TestRuns::Destroy, as: :destroy
+
+          get '/results', to: Inferno::Web::Controllers::TestRuns::Results::Index, as: :results
+        end
+
+        scope 'test_sessions' do
+          post '/', to: Inferno::Web::Controllers::TestSessions::Create, as: :create
+          get '/:id', to: Inferno::Web::Controllers::TestSessions::Show, as: :show
+
+          get '/:id/last_test_run',
               to: Inferno::Web::Controllers::TestSessions::LastTestRun,
               as: :last_test_run
+          get '/:id/results',
+              to: Inferno::Web::Controllers::TestSessions::Results::Index,
+              as: :results
+          get '/:id/session_data',
+              to: Inferno::Web::Controllers::TestSessions::SessionData::Index
+          put '/:id/session_data/apply_preset',
+              to: Inferno::Web::Controllers::TestSessions::SessionData::ApplyPreset,
+              as: :session_data_apply_preset
+        end
 
-          resources 'test_suites', only: [:index, :show]
-          put 'test_suites/:id/check_configuration',
+        scope 'test_suites' do
+          get '/', to: Inferno::Web::Controllers::TestSuites::Index, as: :index
+          get '/:id', to: Inferno::Web::Controllers::TestSuites::Show, as: :show
+
+          put '/:id/check_configuration',
               to: Inferno::Web::Controllers::TestSuites::CheckConfiguration,
               as: :check_configuration
+        end
 
-          resources 'requests', only: [:show]
+        get '/requests/:id', to: Inferno::Web::Controllers::Requests::Show, as: :requests_show
 
-          get '/version', to: ->(_env) { [200, {}, [{ 'version' => Inferno::VERSION.to_s }.to_json]] }, as: :api_version
-        end
+        get '/version', to: ->(_env) { [200, {}, [{ 'version' => Inferno::VERSION.to_s }.to_json]] }, as: :version
+      end
 
-        # Should not need Content-Type header but GitHub Codespaces will not work without them.
-        # This could be investigated and likely removed if addressed properly elsewhere.
-        get '/', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
-        get '/test_sessions/:id', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
-
-        Inferno.routes.each do |route|
-          cleaned_id = route[:suite].id.gsub(/[^a-zA-Z\d\-._~]/, '_')
-          path = "/custom/#{cleaned_id}#{route[:path]}"
-          Application['logger'].info("Registering custom route: #{path}")
-          if route[:method] == :all
-            mount route[:handler], at: path
-          else
-            send(route[:method], path, to: route[:handler])
-          end
-        end
+      # Should not need Content-Type header but GitHub Codespaces will not work without them.
+      # This could be investigated and likely removed if addressed properly elsewhere.
+      get '/', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
+      get '/test_sessions/:id', to: ->(_env) { [200, { 'Content-Type' => 'text/html' }, [client_page]] }
 
-        Inferno::Repositories::TestSuites.all.map { |suite| "/#{suite.id}" }.each do |suite_path|
-          Application['logger'].info("Registering suite route: #{suite_path}")
-          get suite_path, to: ->(_env) { [200, {}, [client_page]] }
+      Inferno.routes.each do |route|
+        cleaned_id = route[:suite].id.gsub(/[^a-zA-Z\d\-._~]/, '_')
+        path = "/custom/#{cleaned_id}#{route[:path]}"
+        Application['logger'].info("Registering custom route: #{path}")
+        if route[:method] == :all
+          mount route[:handler], at: path
+        else
+          send(route[:method], path, to: route[:handler])
         end
       end
+
+      Inferno::Repositories::TestSuites.all.map { |suite| "/#{suite.id}" }.each do |suite_path|
+        Application['logger'].info("Registering suite route: #{suite_path}")
+        get suite_path, to: ->(_env) { [200, {}, [client_page]] }
+      end
     end
   end
 end

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

@@ -1,3 +1,5 @@
+require_relative 'serializer'
+
 module Inferno
   module Web
     module Serializers

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

@@ -1,3 +1,5 @@
+require_relative 'serializer'
+
 module Inferno
   module Web
     module Serializers
@@ -6,11 +8,6 @@ module Inferno
           identifier :id
           field :title
         end
-
-        # view :full do
-        #   include_view :summary
-        #   field :inputs, blueprint: Input
-        # end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+require_relative 'header'
+
 module Inferno
   module Web
     module Serializers

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

@@ -1,4 +1,5 @@
 require 'json'
+require_relative 'message'
 require_relative 'request'
 
 module Inferno

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

@@ -1,3 +1,5 @@
+require_relative 'serializer'
+
 module Inferno
   module Web
     module Serializers

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

@@ -1,3 +1,5 @@
+require_relative 'serializer'
+
 module Inferno
   module Web
     module Serializers

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

@@ -1,3 +1,6 @@
+require_relative 'hash_value_extractor'
+require_relative 'input'
+
 module Inferno
   module Web
     module Serializers

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

@@ -1,3 +1,5 @@
+require_relative 'test'
+
 module Inferno
   module Web
     module Serializers
@@ -19,11 +21,11 @@ module Inferno
         end
         field :test_groups do |group, options|
           suite_options = options[:suite_options]
-          TestGroup.render_as_hash(group.groups(suite_options), suite_options: suite_options)
+          TestGroup.render_as_hash(group.groups(suite_options), suite_options:)
         end
         field :tests do |group, options|
           suite_options = options[:suite_options]
-          Test.render_as_hash(group.tests(suite_options), suite_options: suite_options)
+          Test.render_as_hash(group.tests(suite_options), suite_options:)
         end
         field :inputs do |group, options|
           suite_options = options[:suite_options]

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

@@ -1,3 +1,6 @@
+require_relative 'input'
+require_relative 'result'
+
 module Inferno
   module Web
     module Serializers