inferno_core 0.0.3 → 0.0.4

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)

data/lib/inferno/utils/middleware/request_logger.rb

@@ -29,11 +29,17 @@ module Inferno
 
         def log_response(response, start_time, end_time, exception = nil)
           elapsed = end_time - start_time
-          status, _response_headers, response_body = response if response
+          status, _response_headers, body = response if response
           status, = response if exception
 
           logger.info("#{status} in #{elapsed.in_milliseconds} ms")
-          logger.info(response_body)
+          return unless body.present?
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
         end
 
         def log_request(env)
@@ -47,7 +53,14 @@ module Inferno
           query_string = query.blank? ? '' : "?#{query}"
 
           logger.info("#{method} #{scheme}://#{host}#{path}#{query_string}")
-          logger.info(body) if body.present?
+
+          return unless body.present?
+
+          if body.length > 100
+            logger.info("#{body[0..100]}...")
+          else
+            logger.info(body)
+          end
         end
       end
     end

data/lib/inferno/version.rb

@@ -1,3 +1,3 @@
 module Inferno
-  VERSION = '0.0.3'.freeze
+  VERSION = '0.0.4'.freeze
 end

data/spec/factories/result.rb

@@ -14,11 +14,19 @@ FactoryBot.define do
     test_suite_id { runnable[:test_suite_id] }
     test_group_id { runnable[:test_group_id] }
     test_id { runnable[:test_id] }
+    output_json { '[]' }
 
     result { 'pass' }
 
     initialize_with { new(**attributes) }
 
+    before(:create) do |instance, evaluator|
+      instance.instance_variable_set(
+        :@requests,
+        repo_create_list(:request, evaluator.request_count, result_id: instance.id)
+      )
+    end
+
     to_create do |instance|
       Inferno::Repositories::Results.new.create(instance.to_hash)
     end

data/spec/factories/test_run.rb

@@ -10,8 +10,10 @@ FactoryBot.define do
     test_suite_id { runnable[:test_suite_id] }
     test_group_id { runnable[:test_group_id] }
     test_id { runnable[:test_id] }
+    status { 'queued' }
 
     inputs { nil }
+    wait_timeout { nil }
 
     initialize_with { new(**attributes) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inferno_core
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Stephen MacVicar
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-21 00:00:00.000000000 Z
+date: 2021-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -96,6 +96,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: fhir_models
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: hanami-controller
   requirement: !ruby/object:Gem::Requirement
@@ -409,7 +423,9 @@ files:
 - lib/inferno/apps/web/controllers/test_runs/results/index.rb
 - lib/inferno/apps/web/controllers/test_runs/show.rb
 - lib/inferno/apps/web/controllers/test_sessions/create.rb
+- lib/inferno/apps/web/controllers/test_sessions/last_test_run.rb
 - lib/inferno/apps/web/controllers/test_sessions/results/index.rb
+- lib/inferno/apps/web/controllers/test_sessions/session_data/index.rb
 - lib/inferno/apps/web/controllers/test_sessions/show.rb
 - lib/inferno/apps/web/controllers/test_suites/index.rb
 - lib/inferno/apps/web/controllers/test_suites/show.rb
@@ -421,6 +437,7 @@ files:
 - lib/inferno/apps/web/serializers/request.rb
 - lib/inferno/apps/web/serializers/result.rb
 - lib/inferno/apps/web/serializers/serializer.rb
+- lib/inferno/apps/web/serializers/session_data.rb
 - lib/inferno/apps/web/serializers/test.rb
 - lib/inferno/apps/web/serializers/test_group.rb
 - lib/inferno/apps/web/serializers/test_run.rb
@@ -430,19 +447,25 @@ files:
 - lib/inferno/config/boot.rb
 - lib/inferno/config/boot/db.rb
 - lib/inferno/config/boot/logging.rb
+- lib/inferno/config/boot/sidekiq.rb
 - lib/inferno/config/boot/suites.rb
 - lib/inferno/config/boot/web.rb
 - lib/inferno/db/migrations/001_create_initial_structure.rb
+- lib/inferno/db/migrations/002_add_wait_support.rb
+- lib/inferno/db/migrations/003_update_session_data.rb
+- lib/inferno/db/migrations/004_add_request_results_table.rb
+- lib/inferno/db/migrations/005_add_updated_at_index_to_results.rb
+- lib/inferno/db/schema.rb
 - lib/inferno/dsl.rb
 - lib/inferno/dsl/assertions.rb
 - lib/inferno/dsl/fhir_client.rb
 - lib/inferno/dsl/fhir_client_builder.rb
-- lib/inferno/dsl/fhir_manipulation.rb
 - lib/inferno/dsl/fhir_validation.rb
 - lib/inferno/dsl/http_client.rb
 - lib/inferno/dsl/http_client_builder.rb
 - lib/inferno/dsl/request_storage.rb
 - lib/inferno/dsl/results.rb
+- lib/inferno/dsl/resume_test_route.rb
 - lib/inferno/dsl/runnable.rb
 - lib/inferno/entities.rb
 - lib/inferno/entities/attributes.rb
@@ -451,13 +474,16 @@ files:
 - lib/inferno/entities/message.rb
 - lib/inferno/entities/request.rb
 - lib/inferno/entities/result.rb
+- lib/inferno/entities/session_data.rb
 - lib/inferno/entities/test.rb
 - lib/inferno/entities/test_group.rb
-- lib/inferno/entities/test_input.rb
 - lib/inferno/entities/test_run.rb
 - lib/inferno/entities/test_session.rb
 - lib/inferno/entities/test_suite.rb
 - lib/inferno/exceptions.rb
+- lib/inferno/jobs.rb
+- lib/inferno/jobs/execute_test_run.rb
+- lib/inferno/jobs/resume_test_run.rb
 - lib/inferno/public/217.bundle.js
 - lib/inferno/public/assets.json
 - lib/inferno/public/bundle.js
@@ -473,6 +499,7 @@ files:
 - lib/inferno/repositories/repository.rb
 - lib/inferno/repositories/requests.rb
 - lib/inferno/repositories/results.rb
+- lib/inferno/repositories/session_data.rb
 - lib/inferno/repositories/test_groups.rb
 - lib/inferno/repositories/test_runs.rb
 - lib/inferno/repositories/test_sessions.rb
@@ -515,7 +542,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Inferno Core is an open source tool for testing data exchanges enabled by