inferno_core 0.0.1 → 0.0.5

data/lib/inferno/repositories/requests.rb

@@ -7,13 +7,13 @@ module Inferno
         request = self.class::Model.create(db_params(params))
 
         request_headers = (params[:request_headers] || []).map do |header|
-          headers_repo.create(header.merge(request_id: request.index, type: 'request'))
+          request.add_header(header.merge(request_id: request.index, type: 'request'))
         end
         response_headers = (params[:response_headers] || []).map do |header|
-          headers_repo.create(header.merge(request_id: request.index, type: 'response'))
+          request.add_header(header.merge(request_id: request.index, type: 'response'))
         end
 
-        headers = request_headers + response_headers
+        headers = (request_headers + response_headers).map { |header| headers_repo.build_entity(header.to_hash) }
 
         build_entity(
           request.to_hash
@@ -73,7 +73,8 @@ module Inferno
       end
 
       class Model < Sequel::Model(db)
-        many_to_one :result, class: 'Inferno::Repositories::Results::Model', key: :result_id
+        many_to_many :result, class: 'Inferno::Repositories::Results::Model', join_table: :requests_results,
+                              left_key: :request_id, right_key: :result_id
         one_to_many :headers, class: 'Inferno::Repositories::Headers::Model', key: :request_id
 
         def before_create

data/lib/inferno/repositories/results.rb

@@ -15,11 +15,43 @@ module Inferno
         messages = params.delete(:messages) || []
         requests = params.delete(:requests) || []
         super(params).tap do |result|
+          result_model = self.class::Model.find(id: result.id)
           messages.each { |message| messages_repo.create(message.merge(result_id: result.id)) }
-          requests.each { |request| requests_repo.create(request.to_hash.merge(result_id: result.id)) }
+          requests.each do |request|
+            request_id =
+              if request.id.present?
+                request.id
+              else
+                requests_repo.create(request.to_hash.merge(result_id: result.id)).id
+              end
+            request_model = requests_repo.class::Model.find(id: request_id)
+            result_model.add_request(request_model)
+          end
         end
       end
 
+      # Get the current result for a particular test/group
+      # @api private
+      # @example
+      #   repo.current_result_for_test_session(
+      #     test_session_id,
+      #     test_id: 'test_id'
+      #   )
+      def current_result_for_test_session(test_session_id, **params)
+        self.class::Model
+          .where({ test_session_id: test_session_id }.merge(params))
+          .order(Sequel.desc(:updated_at))
+          .limit(1)
+          .all
+          .map! do |result_hash|
+            build_entity(
+              result_hash
+                .to_json_data(json_serializer_options)
+                .deep_symbolize_keys!
+            )
+          end.first
+      end
+
       def build_entity(params)
         runnable =
           if params[:test_id]
@@ -34,12 +66,85 @@ module Inferno
         entity_class.new(params.merge(runnable))
       end
 
+      def result_for_test_run(test_run_id:, **params)
+        result_hash =
+          self.class::Model
+            .find({ test_run_id: test_run_id }.merge(params))
+            &.to_hash
+
+        return nil if result_hash.nil?
+
+        build_entity(result_hash)
+      end
+
+      def test_run_results_after(test_run_id:, after:)
+        Model
+          .where(test_run_id: test_run_id)
+          .where { updated_at >= after }
+          .to_a
+          .map! do |result_hash|
+          build_entity(
+            result_hash
+              .to_json_data(json_serializer_options)
+              .deep_symbolize_keys!
+          )
+        end
+      end
+
+      def find_waiting_result(test_run_id:)
+        result_hash =
+          Model
+            .where(test_run_id: test_run_id, result: 'wait')
+            .where { test_id !~ nil }
+            .limit(1)
+            .to_a
+            .first
+            &.to_hash
+
+        return nil if result_hash.nil?
+
+        build_entity(result_hash)
+      end
+
+      # Get all of the current results for a test session
+      def current_results_for_test_session(test_session_id)
+        self.class::Model
+          .current_results_for_test_session(test_session_id)
+          .eager(:messages)
+          .eager(requests: proc { |requests| requests.select(*Entities::Request::SUMMARY_FIELDS) })
+          .all
+          .map! do |result_hash|
+            build_entity(
+              result_hash
+                .to_json_data(json_serializer_options)
+                .deep_symbolize_keys!
+            )
+          end
+      end
+
+      # Get the current results for a list of runnables
+      def current_results_for_test_session_and_runnables(test_session_id, runnables)
+        self.class::Model
+          .current_results_for_test_session_and_runnables(test_session_id, runnables)
+          .all
+          .map! do |result_hash|
+            build_entity(
+              result_hash
+                .to_json_data(json_serializer_options)
+                .deep_symbolize_keys!
+            )
+          end
+      end
+
+      def pass_waiting_result(result_id, message = nil)
+        update(result_id, result: 'pass', result_message: message)
+      end
+
       def json_serializer_options
         {
           include: {
             messages: {},
             requests: {
-              include: { headers: {} },
               only: Entities::Request::SUMMARY_FIELDS
             }
           }
@@ -49,8 +154,33 @@ module Inferno
       class Model < Sequel::Model(db)
         include ValidateRunnableReference
 
+        def self.current_results_sql(with_runnables_filter: false)
+          query = <<~SQL.gsub(/\s+/, ' ').freeze
+            SELECT * FROM results a
+            WHERE test_session_id = :test_session_id
+          SQL
+          runnables_filter = <<~SQL.gsub(/\s+/, ' ').freeze
+            AND (test_id IN :test_ids OR test_group_id IN :test_group_ids OR test_suite_id IN :test_suite_ids)
+          SQL
+          subquery = <<~SQL.gsub(/\s+/, ' ').freeze
+            AND a.id IN  (
+              SELECT id
+              FROM results b
+              WHERE (b.test_session_id = a.test_session_id AND b.test_id = a.test_id) OR
+                    (b.test_session_id = a.test_session_id AND b.test_group_id = a.test_group_id) OR
+                    (b.test_session_id = a.test_session_id AND b.test_suite_id = a.test_suite_id)
+              ORDER BY updated_at DESC
+              LIMIT 1
+            )
+          SQL
+          return "#{query} #{runnables_filter} #{subquery}" if with_runnables_filter
+
+          "#{query} #{subquery}"
+        end
+
         one_to_many :messages, class: 'Inferno::Repositories::Messages::Model', key: :result_id
-        one_to_many :requests, class: 'Inferno::Repositories::Requests::Model', key: :result_id
+        many_to_many :requests, class: 'Inferno::Repositories::Requests::Model', join_table: :requests_results,
+                                left_key: :results_id, right_key: :requests_id
         many_to_one :test_run, class: 'Inferno::Repositories::TestRuns::Model', key: :test_run_id
         many_to_one :test_session, class: 'Inferno::Repositories::TestSessions::Model', key: :test_session_id
 
@@ -66,6 +196,24 @@ module Inferno
           super
           errors.add(:result, "'#{result}' is not valid") unless Entities::Result::RESULT_OPTIONS.include?(result)
         end
+
+        def self.current_results_for_test_session(test_session_id)
+          fetch(current_results_sql, test_session_id: test_session_id)
+        end
+
+        def self.current_results_for_test_session_and_runnables(test_session_id, runnables)
+          test_ids = runnables.select { |runnable| runnable < Entities::Test }.map!(&:id)
+          test_group_ids = runnables.select { |runnable| runnable < Entities::TestGroup }.map!(&:id)
+          test_suite_ids = runnables.select { |runnable| runnable < Entities::TestSuite }.map!(&:id)
+
+          fetch(
+            current_results_sql(with_runnables_filter: true),
+            test_session_id: test_session_id,
+            test_ids: test_ids,
+            test_group_ids: test_group_ids,
+            test_suite_ids: test_suite_ids
+          )
+        end
       end
     end
   end

data/lib/inferno/repositories/session_data.rb

@@ -0,0 +1,47 @@
+module Inferno
+  module Repositories
+    class SessionData < Repository
+      def save(params)
+        name = params[:name].to_s.downcase
+        test_session_id = params[:test_session_id]
+        db
+          .insert_conflict(
+            target: :id,
+            update: { value: params[:value] }
+          ).insert(
+            id: "#{test_session_id}_#{name}",
+            name: name,
+            value: params[:value],
+            test_session_id: test_session_id
+          )
+      end
+
+      def load(test_session_id:, name:)
+        self.class::Model
+          .find(test_session_id: test_session_id, name: name.to_s.downcase)
+          &.value
+      end
+
+      def get_all_from_session(test_session_id)
+        self.class::Model
+          .where(test_session_id: test_session_id)
+          .all
+          .map! do |session_data_hash|
+            build_entity(
+              session_data_hash
+                .to_json_data
+                .deep_symbolize_keys!
+            )
+          end
+      end
+
+      def entity_class_name
+        'SessionData'
+      end
+
+      class Model < Sequel::Model(db)
+        many_to_one :test_session, class: 'Inferno::Repositories::TestSessions::Model', key: :test_session_id
+      end
+    end
+  end
+end

data/lib/inferno/repositories/test_runs.rb

@@ -24,6 +24,65 @@ module Inferno
           .map! { |result| results_repo.build_entity(result) }
       end
 
+      def find_latest_waiting_by_identifier(identifier)
+        test_run_hash =
+          self.class::Model
+            .where(status: 'waiting')
+            .where(identifier: identifier)
+            .where { wait_timeout >= Time.now }
+            .order(Sequel.desc(:updated_at))
+            .limit(1)
+            .to_a
+            &.first
+            &.to_hash
+
+        return nil if test_run_hash.nil?
+
+        build_entity(test_run_hash)
+      end
+
+      def last_test_run(test_session_id)
+        test_run_hash =
+          self.class::Model
+            .where(test_session_id: test_session_id)
+            .order(Sequel.desc(:updated_at))
+            .limit(1)
+            .to_a
+            .map { |record| record.to_json_data(json_serializer_options).deep_symbolize_keys! }
+            &.first
+            &.to_hash
+
+        return nil if test_run_hash.nil?
+
+        build_entity(test_run_hash)
+      end
+
+      def mark_as_running(test_run_id)
+        update(test_run_id, status: 'running')
+      end
+
+      def mark_as_done(test_run_id)
+        update(test_run_id, status: 'done')
+      end
+
+      def mark_as_waiting(test_run_id, identifier, timeout)
+        update(
+          test_run_id,
+          status: 'waiting',
+          identifier: identifier,
+          wait_timeout: Time.now + timeout.seconds
+        )
+      end
+
+      def mark_as_no_longer_waiting(test_run_id)
+        update(
+          test_run_id,
+          status: 'queued',
+          identifier: nil,
+          wait_timeout: nil
+        )
+      end
+
       class Model < Sequel::Model(db)
         include ValidateRunnableReference
 
@@ -33,6 +92,13 @@ module Inferno
                     key: :test_run_id
         many_to_one :test_session, class: 'Inferno::Repositories::TestSessions::Model', key: :test_session_id
 
+        def validate
+          super
+          if status.present? && !Entities::TestRun::STATUS_OPTIONS.include?(status) # rubocop:disable Style/GuardClause
+            errors.add(:status, "'#{status}' is not valid")
+          end
+        end
+
         def before_create
           self.id = SecureRandom.uuid
           time = Time.now

data/lib/inferno/test_runner.rb

@@ -1,73 +1,165 @@
 module Inferno
   # @api private
   class TestRunner
-    attr_reader :test_session, :test_run
+    attr_reader :test_session, :test_run, :resuming
 
-    def initialize(test_session:, test_run:)
+    def initialize(test_session:, test_run:, resume: false)
       @test_session = test_session
       @test_run = test_run
+      @resuming = resume
+    end
+
+    def run_results
+      @run_results ||= {}
     end
 
     def results_repo
       @results_repo ||= Repositories::Results.new
     end
 
-    def run(runnable, inputs = {}, outputs = {})
+    def test_runs_repo
+      @test_runs_repo ||= Repositories::TestRuns.new
+    end
+
+    def session_data_repo
+      @session_data_repo ||= Repositories::SessionData.new
+    end
+
+    def start
+      test_runs_repo.mark_as_running(test_run.id)
+
+      run(test_run.runnable)
+
+      test_runs_repo.mark_as_done(test_run.id) unless run_results.values.any?(&:waiting?)
+
+      run_results.values
+    end
+
+    def run(runnable)
       if runnable < Entities::Test
-        run_test(runnable, inputs, outputs)
+        return existing_test_result(runnable) || run_test(runnable) if resuming
+
+        run_test(runnable)
       else
-        run_group(runnable, inputs, outputs)
+        run_group(runnable)
       end
     end
 
-    def run_test(runnable, inputs = {}, outputs = {})
-      test_instance = runnable.new(inputs: inputs.merge(outputs), test_session_id: test_session.id)
+    def existing_test_result(runnable)
+      results_repo.result_for_test_run(runnable.reference_hash.merge(test_run_id: test_run.id))
+    end
+
+    def run_test(test)
+      inputs = load_inputs(test)
+
+      input_json_string = JSON.generate(inputs)
+      test_instance = test.new(inputs: inputs, test_session_id: test_session.id)
 
       result = begin
-        inputs.merge(outputs).each do |key, value|
-          test_instance.instance_variable_set("@#{key}", value)
-        end
         test_instance.load_named_requests
-        test_instance.instance_eval(&runnable.block)
+        test_instance.instance_eval(&test.block)
         'pass'
       rescue Exceptions::TestResultException => e
         test_instance.result_message = e.message
         e.result
       rescue StandardError => e
+        Application['logger'].error(e.full_message)
         test_instance.result_message = "Error: #{e.message}"
         'error'
       end
 
-      runnable.outputs.each do |output|
-        outputs[output] = test_instance.send(output)
+      outputs = save_outputs(test_instance)
+      output_json_string = JSON.generate(outputs)
+
+      if result == 'wait'
+        test_runs_repo.mark_as_waiting(test_run.id, test_instance.identifier, test_instance.wait_timeout)
       end
 
-      [persist_result(
+      test_result = persist_result(
         {
-          test_session_id: test_session.id,
-          test_run_id: test_run.id,
           messages: test_instance.messages,
           requests: test_instance.requests,
           result: result,
-          result_message: test_instance.result_message
-        }.merge(runnable.reference_hash)
-      )]
+          result_message: test_instance.result_message,
+          input_json: input_json_string,
+          output_json: output_json_string
+        }.merge(test.reference_hash)
+      )
+
+      # If running a single test, update its parents' results. If running a
+      # group or suite, #run_group handles updating the parents.
+      return test_result if test_run.test_id.blank?
+
+      update_parent_result(test.parent)
+
+      test_result
     end
 
-    def run_group(runnable, inputs = {}, outputs = {})
-      results = runnable.children.flat_map { |child| run(child, inputs, outputs) }
+    def run_group(group)
+      results = []
+      group.children.each do |child|
+        result = run(child)
+        results << result
+        break if results.last.waiting?
+      end
 
-      results << persist_result(
-        {
-          test_session_id: test_session.id,
-          test_run_id: test_run.id,
-          result: roll_up_result(results)
-        }.merge(runnable.reference_hash)
-      )
+      results.flatten!
+
+      group_result = persist_result(group.reference_hash.merge(result: roll_up_result(results)))
+
+      update_parent_result(group.parent)
+
+      group_result
+    end
+
+    def update_parent_result(parent)
+      return if parent.nil?
+
+      children = parent.children
+      child_results = results_repo.current_results_for_test_session_and_runnables(test_session.id, children)
+      return if children.length != child_results.length
+
+      old_result = results_repo.current_result_for_test_session(test_session.id, parent.reference_hash)&.result
+      new_result = roll_up_result(child_results)
+
+      if new_result != old_result
+        persist_result(parent.reference_hash.merge(result: new_result))
+
+        update_parent_result(parent.parent)
+      end
+
+      new_result
+    end
+
+    def load_inputs(runnable)
+      runnable.inputs.each_with_object({}) do |input, input_hash|
+        name = input[:name]
+        input_hash[name] = session_data_repo.load(test_session_id: test_session.id, name: name)
+      end
+    end
+
+    def save_outputs(runnable_instance)
+      outputs =
+        runnable_instance.outputs.map do |output_name|
+          {
+            name: output_name,
+            value: runnable_instance.send(output_name)
+          }
+        end
+      outputs.compact!
+      outputs.each do |output|
+        session_data_repo.save(output.merge(test_session_id: test_session.id))
+      end
+
+      outputs
     end
 
     def persist_result(params)
-      results_repo.create(params)
+      result = results_repo.create(
+        params.merge(test_run_id: test_run.id, test_session_id: test_session.id)
+      )
+
+      run_results[result.runnable.id] = result
     end
 
     def roll_up_result(results)