inferno_core 0.4.43 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f9e6a4ff6df2749650a972de54dbf8e693de38469c3ac8cb781ee99cbf6ce4'
-  data.tar.gz: 2153922e52c9207e092526b7a0bedaca8b9333530c4c2e41515083001ba09097
+  metadata.gz: 5c6ddae6726754b2036409f6765ffd3746e88a2238226655905332ac9083a907
+  data.tar.gz: a7f8fe7d9eedd5213bd9d825fc32075b00abf69953c29ab550c45b66fc0147b6
 SHA512:
-  metadata.gz: fe29bbefe0208e36c4e9919dba3292f35779f1c9d8e9810e98b03837ef73b3538bf19bd752e659733da7bc6b646a190249a7017b44ff45a679e29b2faa3d91fe
-  data.tar.gz: 8b43e4f565366c80930ab4150c1c1a493fc8fe8551295851ef49eef213e42a185521abd62438e5a0514f51463968bf24e84824aa72c9ef20f5880a65b5145cb1
+  metadata.gz: bfbb7ef6d15895b029349446501d739b7e676cff8e0ea369c1f781ee29151187eaba602f4485cee34a19c9a492d1cdbe2e4db3454db5f33a8f7b578586c53685
+  data.tar.gz: 14cb75b1bbaa2dcca319348f9914cf2af5d40d36a23ab7de3d212e43555466dc5f7c6d1af9a570fcca977e16353df80bc76f891616b32f0d91a593cfb9378730

data/lib/inferno/apps/cli/execute/console_outputter.rb

@@ -0,0 +1,152 @@
+require 'pastel'
+require_relative '../../web/serializers/test_run'
+require_relative '../../web/serializers/result'
+
+module Inferno
+  module CLI
+    class Execute
+      # @private
+      class ConsoleOutputter
+        COLOR = Pastel.new
+        CHECKMARK = "\u2713".freeze
+        BAR = ('=' * 80).freeze
+
+        def print_start_message(options)
+          puts ''
+          puts BAR
+          puts "Testing #{options[:suite]}"
+          verbose_puts options, "Running Groups #{options[:groups]}" unless options[:groups].blank?
+          verbose_puts options, "Running Tests #{options[:tests]}" unless options[:tests].blank?
+          verbose_puts options, "Running Entities #{options[:short_ids]}" unless options[:short_ids].blank?
+          puts BAR
+        end
+
+        def print_around_run(_options)
+          puts 'Running tests. This may take a while...'
+          # TODO: spinner/progress bar
+          yield
+        end
+
+        def print_results(options, results)
+          verbose_print_json_results(options, results)
+
+          puts BAR
+          puts 'Test Results:'
+          puts BAR
+          results.each do |result|
+            print format_tag(result), ': ', format_result(result), "\n"
+            verbose_puts(options, "\tsummary: ",     result.result_message)
+            verbose_puts(options, "\tmessages: ",    format_messages(result))
+            verbose_puts(options, "\trequests: ",    format_requests(result))
+            verbose_puts(options, "\tinputs: ",      format_inputs(result))
+            verbose_puts(options, "\toutputs: ",     format_outputs(result))
+          end
+          puts BAR
+        end
+
+        def print_end_message(options); end
+
+        def print_error(options, exception)
+          puts COLOR.red "Error: #{exception.full_message}"
+          verbose_print(options, exception.backtrace&.join('\n'))
+        end
+
+        # private
+
+        def verbose_print(options, *args)
+          print(COLOR.dim(*args)) if options[:verbose]
+        end
+
+        def verbose_puts(options, *args)
+          args.push("\n")
+          verbose_print(options, *args)
+        end
+
+        def format_tag(result)
+          if result.runnable.respond_to?(:short_id)
+            "#{result.runnable.short_id} #{format_tag_suffix(result)}"
+          else
+            format_tag_suffix(result)
+          end
+        end
+
+        def format_tag_suffix(result)
+          result.runnable.short_title.presence || result.runnable.title.presence || result.runnable.id
+        end
+
+        def format_messages(result)
+          result.messages.map do |message|
+            "\n\t\t#{message.type}: #{message.message}"
+          end.join
+        end
+
+        def format_requests(result)
+          result.requests.map do |req_res|
+            "\n\t\t#{req_res.status} #{req_res.verb.upcase} #{req_res.url}"
+          end.join
+        end
+
+        def format_session_data(result, attr)
+          json = result.send(attr)
+          return '' if json.nil?
+
+          JSON.parse(json).map do |hash|
+            "\n\t\t#{hash['name']}: #{hash['value']}"
+          end.join
+        end
+
+        def format_inputs(result)
+          format_session_data(result, :input_json)
+        end
+
+        def format_outputs(result)
+          format_session_data(result, :output_json)
+        end
+
+        def format_result(result) # rubocop:disable Metrics/CyclomaticComplexity
+          case result.result
+          when 'pass'
+            COLOR.bold.green(CHECKMARK, ' pass')
+          when 'fail'
+            COLOR.bold.red 'X fail'
+          when 'skip'
+            COLOR.yellow '* skip'
+          when 'omit'
+            COLOR.blue '* omit'
+          when 'error'
+            COLOR.magenta 'X error'
+          when 'wait'
+            COLOR.bold '. wait'
+          when 'cancel'
+            COLOR.red 'X cancel'
+          when 'running'
+            COLOR.bold '- running'
+          else
+            raise StandardError.new, "Unrecognized result #{result.result}"
+          end
+        end
+
+        def verbose_print_json_results(options, results)
+          verbose_puts(options, BAR)
+          verbose_puts(options, 'JSON Test Results:')
+          verbose_puts(options, BAR)
+          verbose_puts(options, serialize(results))
+          verbose_puts(options, BAR)
+        end
+
+        def serialize(entity)
+          case entity.class.to_s
+          when 'Array'
+            JSON.pretty_generate(entity.map { |item| JSON.parse serialize(item) })
+          when lambda { |x|
+                 defined?(x.constantize) && defined?("Inferno::Web::Serializers::#{x.split('::').last}".constantize)
+               }
+            "Inferno::Web::Serializers::#{entity.class.to_s.split('::').last}".constantize.render(entity)
+          else
+            raise StandardError, "CLI does not know how to serialize #{entity.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/execute.rb

@@ -0,0 +1,269 @@
+require 'pastel'
+require 'active_support'
+require_relative '../../utils/verify_runnable'
+require_relative '../../utils/persist_inputs'
+require_relative 'execute/console_outputter'
+require_relative '../../result_summarizer'
+
+module Inferno
+  module CLI
+    class Execute
+      include ::Inferno::Utils::VerifyRunnable
+      include ::Inferno::Utils::PersistInputs
+
+      attr_accessor :options
+
+      def self.suppress_output
+        begin
+          original_stdout = $stdout.clone
+          $stdout.reopen(File.new(File::NULL, 'w+'))
+          retval = yield
+        ensure
+          $stdout.reopen(original_stdout)
+        end
+        retval
+      end
+
+      def self.boot_full_inferno
+        ENV['NO_DB'] = 'false'
+
+        # Inferno boot flow triggers migration and logger outputs it
+        Inferno::CLI::Execute.suppress_output { require_relative '../../../inferno' }
+
+        Inferno::Application.start(:executor)
+      end
+
+      def run(options)
+        print_help_and_exit if options[:help]
+
+        self.options = options
+
+        outputter.print_start_message(options)
+
+        results = []
+        outputter.print_around_run(options) do
+          if all_selected_groups_and_tests.empty?
+            test_run = create_test_run(suite)
+            run_one(suite, test_run)
+
+            results = test_runs_repo.results_for_test_run(test_run.id)
+            results = sort_results(results)
+          else
+            all_selected_groups_and_tests.each do |runnable|
+              test_run = create_test_run(runnable)
+              run_one(runnable, test_run)
+
+              results += sort_results(test_runs_repo.results_for_test_run(test_run.id))
+            end
+          end
+        end
+
+        # User may enter duplicate runnables, in which case this prevents a bug of extraneous results
+        results.uniq!(&:id)
+
+        outputter.print_results(options, results)
+        outputter.print_end_message(options)
+
+        # TODO: respect customized rollups
+        exit(0) if Inferno::ResultSummarizer.new(results).summarize == 'pass'
+
+        # exit(1) is for Thor failures
+        # exit(2) is for shell builtin failures
+        exit(3)
+      rescue Sequel::ValidationFailed => e
+        print_error_and_exit(e, 4)
+      rescue Sequel::ForeignKeyConstraintViolation => e
+        print_error_and_exit(e, 5)
+      rescue Inferno::Exceptions::RequiredInputsNotFound => e
+        print_error_and_exit(e, 6)
+      rescue Inferno::Exceptions::NotUserRunnableException => e
+        print_error_and_exit(e, 7)
+      rescue StandardError => e
+        print_error_and_exit(e, 8)
+      end
+
+      def print_help_and_exit
+        puts `NO_DB=true bundle exec inferno help execute`
+        exit(0)
+      end
+
+      def outputter
+        # TODO: swap outputter based on options
+        @outputter ||= Inferno::CLI::Execute::ConsoleOutputter.new
+      end
+
+      def all_selected_groups_and_tests
+        @all_selected_groups_and_tests ||= runnables_by_short_id + groups + tests
+      end
+
+      def run_one(runnable, test_run)
+        verify_runnable(
+          runnable,
+          thor_hash_to_inputs_array(options[:inputs]),
+          test_session.suite_options
+        )
+
+        persist_inputs(session_data_repo, create_params(test_session, suite), test_run)
+
+        dispatch_job(test_run)
+      end
+
+      def suite
+        @suite ||= Inferno::Repositories::TestSuites.new.find(options[:suite])
+
+        raise StandardError, "Test suite #{options[:suite]} not found" if @suite.nil?
+
+        @suite
+      end
+
+      def test_runs_repo
+        @test_runs_repo ||= Inferno::Repositories::TestRuns.new
+      end
+
+      def create_test_run(runnable)
+        test_runs_repo.create(
+          create_params(test_session, runnable).merge({ status: 'queued' })
+        )
+      end
+
+      def results_repo
+        @results_repo ||= Inferno::Repositories::Results.new
+      end
+
+      def test_groups_repo
+        @test_groups_repo ||= Inferno::Repositories::TestGroups.new
+      end
+
+      def tests_repo
+        @tests_repo ||= Inferno::Repositories::Tests.new
+      end
+
+      def test_sessions_repo
+        @test_sessions_repo ||= Inferno::Repositories::TestSessions.new
+      end
+
+      def session_data_repo
+        @session_data_repo ||= Inferno::Repositories::SessionData.new
+      end
+
+      def test_session
+        @test_session ||= test_sessions_repo.create({
+                                                      test_suite_id: suite.id,
+                                                      suite_options: thor_hash_to_suite_options_array(
+                                                        options[:suite_options]
+                                                      )
+                                                    })
+      end
+
+      def create_params(test_session, runnable)
+        {
+          test_session_id: test_session.id,
+          runnable_id_key(runnable) => runnable.id,
+          inputs: thor_hash_to_inputs_array(options[:inputs])
+        }
+      end
+
+      def dispatch_job(test_run)
+        # TODO: move suppression to outputter? better suppression?
+        if options[:verbose]
+          Jobs.perform(Jobs::ExecuteTestRun, test_run.id, force_synchronous: true)
+        else
+          Inferno::CLI::Execute.suppress_output do
+            Jobs.perform(Jobs::ExecuteTestRun, test_run.id, force_synchronous: true)
+          end
+        end
+      end
+
+      def runnables_by_short_id
+        return [] if options[:short_ids].blank?
+
+        @runnables_by_short_id ||= options[:short_ids]&.map { |short_id| find_by_short_id(:group_or_test, short_id) }
+      end
+
+      def groups
+        return [] if options[:groups].blank?
+
+        @groups ||= options[:groups]&.map { |short_id| find_by_short_id(:group, short_id) }
+      end
+
+      def tests
+        return [] if options[:tests].blank?
+
+        @tests ||= options[:tests]&.map { |short_id| find_by_short_id(:test, short_id) }
+      end
+
+      def find_by_short_id(repo_symbol, short_id)
+        repo_symbol_to_array(repo_symbol).each do |repo|
+          repo.all.each do |entity|
+            return entity if short_id == entity.short_id && suite.id == entity.suite.id
+          end
+        end
+        raise StandardError, "#{repo_symbol.to_s.humanize} #{short_id} not found."
+      end
+
+      def repo_symbol_to_array(repo_symbol)
+        case repo_symbol
+        when :group
+          [test_groups_repo]
+        when :test
+          [tests_repo]
+        when :group_or_test
+          [test_groups_repo, tests_repo]
+        else
+          raise StandardError, "Unrecognized repo_symbol #{repo_symbol} for `find_by_short_id`"
+        end
+      end
+
+      def thor_hash_to_suite_options_array(hash = {})
+        hash.to_a.map { |pair| Inferno::DSL::SuiteOption.new({ id: pair[0], value: pair[1] }) }
+      end
+
+      def thor_hash_to_inputs_array(hash = {})
+        hash.to_a.map { |pair| { name: pair[0], value: pair[1] } }
+      end
+
+      def print_error_and_exit(err, code)
+        outputter.print_error(options || {}, err)
+      rescue StandardError => e
+        puts "Caught exception #{e} while printing exception #{err}. Exiting."
+      ensure
+        exit(code)
+      end
+
+      def runnable_type(runnable)
+        if runnable < Inferno::TestSuite
+          :suite
+        elsif runnable < Inferno::TestGroup
+          :group
+        elsif runnable < Inferno::Test
+          :test
+        else
+          raise StandardError, "Unidentified runnable #{runnable}"
+        end
+      end
+
+      def runnable_id_key(runnable)
+        case runnable_type(runnable)
+        when :suite
+          :test_suite_id
+        when :group
+          :test_group_id
+        else
+          :test_id
+        end
+      end
+
+      def sort_results(results)
+        results.sort do |result, other|
+          if result.runnable < Inferno::TestSuite
+            -1
+          elsif other.runnable < Inferno::TestSuite
+            1
+          else
+            result.runnable.short_id <=> other.runnable.short_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/main.rb

@@ -5,6 +5,7 @@ require_relative 'suite'
 require_relative 'suites'
 require_relative 'new'
 require_relative '../../version'
+require_relative 'execute'
 
 module Inferno
   module CLI
@@ -65,18 +66,86 @@ module Inferno
         puts "Inferno Core v#{Inferno::VERSION}"
       end
 
+      EXECUTE_HELP = <<~END_OF_HELP.freeze
+        Run Inferno tests in the command line. Exits with 0 only if test entity passes.
+        Must be run with test kit as working directory.
+
+        You must have background services running: `bundle exec inferno services start`
+
+        You can view suite ids with: `bundle exec inferno suites`
+
+        Examples:
+
+            (These examples only work from within the inferno_core directory).
+
+            `bundle exec inferno execute --suite dev_validator \
+                                        --inputs "url:https://hapi.fhir.org/baseR4" \
+                                                 patient_id:1234321`
+            => Outputs test results
+
+            `bundle exec inferno execute --suite dev_validator \
+                                         --inputs "url:https://hapi.fhir.org/baseR4" \
+                                                  patient_id:1234321 \
+                                         --tests 1.01 1.02`
+            => Run specific tests from suite
+      END_OF_HELP
+      desc 'execute', 'Run Inferno tests in command line'
+      long_desc EXECUTE_HELP, wrap: false
+      option :suite,
+             aliases: ['-s'],
+             type: :string,
+             desc: 'Test suite id to run or to select groups and tests from',
+             banner: 'id'
+      option :suite_options,
+             aliases: ['-u'], # NOTE: -o will be for outputter
+             type: :hash,
+             desc: 'Suite options'
+      option :groups,
+             aliases: ['-g'],
+             type: :array,
+             desc: 'Series of test group short ids (AKA sequence number) to run, requires suite'
+      option :tests,
+             aliases: ['-t'],
+             type: :array,
+             desc: 'Series of test short ids (AKA sequence number) to run, requires suite'
+      option :short_ids,
+             aliases: ['-r'],
+             type: :array,
+             desc: 'Series of test or group short ids (AKA sequence number) to run, requires suite'
+      option :inputs,
+             aliases: ['-i'],
+             type: :hash,
+             desc: 'Inputs (i.e: --inputs=foo:bar goo:baz)'
+      option :verbose,
+             aliases: ['-v'],
+             type: :boolean,
+             default: false,
+             desc: 'Output additional information for debugging'
+      option :help,
+             aliases: ['-h'],
+             type: :boolean,
+             default: false,
+             desc: 'Display this message'
+      def execute
+        Execute.boot_full_inferno
+        Execute.new.run(options)
+      end
+
+      # https://github.com/rails/thor/issues/244 - Make Thor exit(1) on Errors/Exceptions
+      def self.exit_on_failure?
+        true
+      end
+
       private
 
       # https://github.com/rubocop/rubocop/issues/12571 - still affects Ruby 3.1 upto Rubocop 1.63
-      # rubocop:disable Naming/BlockForwarding
-      def without_bundler(&block)
+      def without_bundler(&)
         if defined?(Bundler) && ENV['BUNDLE_GEMFILE']
-          Bundler.with_unbundled_env(&block)
+          Bundler.with_unbundled_env(&)
         else
           yield
         end
       end
-      # rubocop:enable Naming/BlockForwarding
     end
   end
 end

data/lib/inferno/apps/cli/templates/.env.development

@@ -1,2 +1,3 @@
 FHIR_RESOURCE_VALIDATOR_URL=http://localhost/hl7validatorapi
-REDIS_URL=redis://localhost:6379/0
+REDIS_URL=redis://localhost:6379/0
+FHIRPATH_URL=http://localhost/fhirpath

data/lib/inferno/apps/cli/templates/.env.production

@@ -1,2 +1,3 @@
 REDIS_URL=redis://redis:6379/0
-FHIR_RESOURCE_VALIDATOR_URL=http://hl7_validator_service:3500
+FHIR_RESOURCE_VALIDATOR_URL=http://hl7_validator_service:3500
+FHIRPATH_URL=http://fhirpath:6789

data/lib/inferno/apps/cli/templates/.env.test

@@ -1,2 +1,3 @@
 FHIR_RESOURCE_VALIDATOR_URL=https://example.com/validatorapi
 ASYNC_JOBS=false
+FHIRPATH_URL=https://example.com/fhirpath

data/lib/inferno/apps/cli/templates/.gitignore

@@ -12,6 +12,7 @@
 .settings/org.eclipse.wst.jsdt.ui.superType.container
 .settings/org.eclipse.wst.jsdt.ui.superType.name
 .idea
+*.gem
 
 /coverage
 /spec/examples.txt

data/lib/inferno/apps/cli/templates/config/nginx.background.conf.tt

@@ -98,5 +98,20 @@ http {
 
       proxy_pass http://hl7_validator_service:3500/;
     }
+
+    location /fhirpath/ {
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Forwarded-Proto $scheme;
+      proxy_set_header X-Forwarded-Port $server_port;
+      proxy_redirect off;
+      proxy_set_header Connection '';
+      proxy_http_version 1.1;
+      chunked_transfer_encoding off;
+      proxy_buffering off;
+      proxy_cache off;
+
+      proxy_pass http://fhirpath:6789/;
+    }
   }
 }

data/lib/inferno/apps/cli/templates/docker-compose.background.yml.tt

@@ -23,6 +23,10 @@ services:
     environment:
       EXTERNAL_VALIDATOR_URL: http://localhost/validatorapi
       VALIDATOR_BASE_PATH: /validator
+  fhirpath:
+    image: infernocommunity/fhirpath-service
+    ports:
+      - "6789:6789"
   nginx:
     image: nginx
     volumes:
@@ -32,6 +36,7 @@ services:
     command: [nginx, '-g', 'daemon off;']
     depends_on:
       - fhir_validator_app
+      - fhirpath
   redis:
     image: redis
     ports:

data/lib/inferno/apps/cli/templates/docker-compose.yml.tt

@@ -27,6 +27,10 @@ services:
     extends:
       file: docker-compose.background.yml
       service: fhir_validator_app
+  fhirpath:
+    extends:
+      file: docker-compose.background.yml
+      service: fhirpath
   nginx:
     extends:
       file: docker-compose.background.yml

data/lib/inferno/apps/cli.rb

@@ -1,5 +1,4 @@
 require 'thor'
-
 require_relative 'cli/main'
 
 module Inferno

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

@@ -1,8 +1,14 @@
+require_relative '../../../../utils/verify_runnable'
+require_relative '../../../../utils/persist_inputs'
+
 module Inferno
   module Web
     module Controllers
       module TestRuns
         class Create < Controller
+          include ::Inferno::Utils::VerifyRunnable
+          include ::Inferno::Utils::PersistInputs
+
           include Import[
                     test_sessions_repo: 'inferno.repositories.test_sessions',
                     session_data_repo: 'inferno.repositories.session_data',
@@ -11,37 +17,6 @@ module Inferno
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
 
-          def verify_runnable(runnable, inputs, selected_suite_options)
-            missing_inputs = runnable&.missing_inputs(inputs, selected_suite_options)
-            user_runnable = runnable&.user_runnable?
-            raise Inferno::Exceptions::RequiredInputsNotFound, missing_inputs if missing_inputs&.any?
-            raise Inferno::Exceptions::NotUserRunnableException unless user_runnable
-          end
-
-          def persist_inputs(params, test_run)
-            available_inputs = test_run.runnable.available_inputs
-            params[:inputs]&.each do |input_params|
-              input =
-                available_inputs
-                  .find { |_, runnable_input| runnable_input.name == input_params[:name] }
-                  &.last
-
-              if input.nil?
-                Inferno::Application['logger'].warn(
-                  "Unknown input `#{input_params[:name]}` for #{test_run.runnable.id}: #{test_run.runnable.title}"
-                )
-                next
-              end
-
-              session_data_repo.save(
-                test_session_id: test_run.test_session_id,
-                name: input.name,
-                value: input_params[:value],
-                type: input.type
-              )
-            end
-          end
-
           def handle(req, res)
             test_session = test_sessions_repo.find(req.params[:test_session_id])
 
@@ -60,7 +35,7 @@ module Inferno
 
             res.body = serialize(test_run, suite_options: test_session.suite_options)
 
-            persist_inputs(req.params, test_run)
+            persist_inputs(session_data_repo, req.params, test_run)
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,

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

@@ -1,3 +1,6 @@
+require 'oj'
+require 'blueprinter'
+
 module Inferno
   module Web
     module Serializers