inferno_core 0.0.5 → 0.0.8.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b643b7c720a9c79df5f329a9947110971076db80fe29f0b57928230cf348d1b
-  data.tar.gz: e03d93994e7ad33e6e131969af5e31449390d36670d256a7d4bf43c1a9f80e4d
+  metadata.gz: 323de6e32c25feac594840493d69222a2388bdabef39c36a5d378a1cfeb2b7cc
+  data.tar.gz: d08c713be3303b146a40a6316765e017d76a4213e3981c6121fd502e7eb4e577
 SHA512:
-  metadata.gz: 4767e5dfd7f469a6eb70892fb9e5402f2a46708655810b91be0b3d1d9d1dfa839c3502678156f763f5e9a7999948a31013fb68e3a1d1605306d5297639f3b3c3
-  data.tar.gz: 3adbce3ebb0786095826a114e4c6bc6a3ced2f9e560e2eaa6f6e6f6784bbf44c10ef25734f67bb097ee384b4cd6ab3296dc156e2c14cd5085bc64cb4fb27f575
+  metadata.gz: 1dfa395166fd30624510ff16f12a216b5580f60265bf8512391fd50d731c9bf7022aec60fa0527aa55e7de48d7fc38c16bb2b4777666c7947c632f6ce4dc2c6a
+  data.tar.gz: 207262300f159a2eb75bca71f95c8550169dc19488e826d4a2e97556d3c9722ce9bdf97436c9f862cddde5ab62b9d2be4895703c02da5c8eac6cf24cdb4e4475

data/bin/inferno

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'pry'
+require_relative '../lib/inferno/config/application'
+require_relative '../lib/inferno/apps/cli'
+
+Inferno::CLI::Main.start

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

@@ -0,0 +1,12 @@
+module Inferno
+  module CLI
+    class Console
+      def run
+        require_relative '../../../inferno'
+
+        Inferno::Application.finalize!
+        Pry.start
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'console'
+require_relative 'migration'
+
+module Inferno
+  module CLI
+    class Main < Thor
+      desc 'console', 'Start an interactive console session with Inferno'
+      def console
+        Console.new.run
+      end
+
+      desc 'migrate', 'Run database migrations'
+      def migrate
+        Migration.new.run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require_relative '../../utils/migration'
+
+module Inferno
+  module CLI
+    class Migration
+      def run
+        Inferno::Application.start(:logging)
+        Inferno::Application['logger'].level = Logger::DEBUG
+
+        Utils::Migration.new.run
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli.rb

@@ -0,0 +1,8 @@
+require 'thor'
+
+require_relative 'cli/main'
+
+module Inferno
+  module CLI
+  end
+end

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

@@ -5,7 +5,8 @@ module Inferno
         class Create < Controller
           include Import[
                     test_sessions_repo: 'repositories.test_sessions',
-                    session_data_repo: 'repositories.session_data'
+                    session_data_repo: 'repositories.session_data',
+                    test_runs_repo: 'repositories.test_runs'
                   ]
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
@@ -14,8 +15,18 @@ module Inferno
             test_session = test_sessions_repo.find(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
+            end
 
             test_run = repo.create(create_params(params).merge(status: 'queued'))
+            missing_inputs = test_run.runnable.missing_inputs(params[:inputs])
+
+            raise Inferno::Exceptions::RequiredInputsNotFound, missing_inputs if missing_inputs.any?
+            raise Inferno::Exceptions::NotUserRunnableException unless test_run.runnable.user_runnable?
+
             self.body = serialize(test_run)
 
             params[:inputs]&.each do |input|
@@ -27,7 +38,9 @@ module Inferno
             end
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
-          rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation => e
+          rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
+                 Inferno::Exceptions::RequiredInputsNotFound,
+                 Inferno::Exceptions::NotUserRunnableException => e
             self.body = { errors: e.message }.to_json
             self.status = 422
           rescue StandardError => e

data/lib/inferno/apps/web/index.html.erb

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
+    <base href="/">
     <meta charset="utf-8" />
     <link rel="icon" href="/public/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />

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

@@ -0,0 +1,11 @@
+module Inferno
+  module Web
+    module Serializers
+      class HashValueExtractor < Blueprinter::Extractor
+        def extract(field_name, object, _local_options, _options)
+          object.send(field_name).values
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,10 @@ module Inferno
       class Test < Serializer
         identifier :id
         field :title
-        field :inputs
-        field :outputs do |test, _options|
-          test.outputs.map { |output| { name: output } }
-        end
+        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :output_definitions, name: :outputs, extractor: HashValueExtractor
         field :description
+        field :user_runnable?, name: :user_runnable
       end
     end
   end

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

@@ -4,18 +4,16 @@ module Inferno
       class TestGroup < Serializer
         identifier :id
 
-        # TODO: fill out test group
         field :title
         field :description
         field :test_count
-        # field :run_as_group
+        field :run_as_group?, name: :run_as_group
+        field :user_runnable?, name: :user_runnable
 
         association :groups, name: :test_groups, blueprint: TestGroup
         association :tests, blueprint: Test
-        field :inputs
-        field :outputs do |group, _options|
-          group.outputs.map { |input| { name: input } }
-        end
+        field :input_definitions, name: :inputs, extractor: HashValueExtractor, blueprint: Input
+        field :output_definitions, name: :outputs, extractor: HashValueExtractor
       end
     end
   end

data/lib/inferno/config/application.rb

@@ -1,4 +1,7 @@
+require 'active_support/all'
+require 'dotenv'
 require 'dry/system/container'
+require 'sequel'
 require_relative 'boot'
 
 module Inferno
@@ -9,6 +12,7 @@ module Inferno
 
     Application.register('js_host', ENV.fetch('JS_HOST', ''))
     Application.register('async_jobs', ENV['ASYNC_JOBS'] != 'false')
+    Application.register('inferno_host', ENV.fetch('INFERNO_HOST', 'http://localhost:4567'))
 
     configure do |config|
       config.root = File.expand_path('../../..', __dir__)

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

@@ -12,6 +12,7 @@ Inferno::Application.boot(:db) do
     config = YAML.load_file(config_path)[ENV['APP_ENV']]
       .merge(logger: Inferno::Application['logger'])
     connection = Sequel.connect(config)
+    connection.sql_log_level = :debug
 
     register('db.config', config)
     register('db.connection', connection)
@@ -19,14 +20,5 @@ Inferno::Application.boot(:db) do
 
   start do
     Sequel.extension :migration
-    db = Inferno::Application['db.connection']
-    migration_path = File.join(Inferno::Application.root, 'lib', 'inferno', 'db', 'migrations')
-    Sequel::Migrator.run(db, migration_path)
-
-    if ENV['APP_ENV'] == 'development'
-      schema_path = File.join(Inferno::Application.root, 'lib', 'inferno', 'db', 'schema.rb')
-      db.extension :schema_dumper
-      File.open(schema_path, 'w') { |f| f.print(db.dump_schema_migration) }
-    end
   end
 end

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

@@ -11,6 +11,8 @@ Inferno::Application.boot(:logging) do
         Logger.new($stdout)
       end
 
+    logger.level = Logger::INFO
+
     register('logger', logger)
   end
 end

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

@@ -4,12 +4,10 @@ Inferno::Application.boot(:suites) do
 
     files_to_load = Dir.glob(File.join(Dir.pwd, 'lib', '*.rb'))
 
-    if ENV['LOAD_DEV_SUITES'] == 'true'
-      files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'dev_suites', '**', '*.rb'))
-    end
-
-    if ENV['LOAD_UI_SUITES'] == 'true'
-      files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'ui_suites', '**', '*.rb'))
+    if ENV['LOAD_DEV_SUITES'].present?
+      ENV['LOAD_DEV_SUITES'].split(',').map(&:strip).reject(&:empty?).each do |suite|
+        files_to_load.concat Dir.glob(File.join(Inferno::Application.root, 'dev_suites', suite, '**', '*.rb'))
+      end
     end
 
     if ENV['APP_ENV'] == 'test'

data/lib/inferno/db/migrations/001_create_initial_structure.rb

@@ -116,7 +116,7 @@ Sequel.migration do
       # Requires requests to be a part of tests now.
       foreign_key :result_id, :results, index: true, type: String
       foreign_key :test_session_id, :test_sessions, index: true, type: String
-      add_index [:test_session_id, :name], concurrently: true
+      index [:test_session_id, :name], concurrently: true
 
       column :created_at, DateTime, null: false
       column :updated_at, DateTime, null: false

data/lib/inferno/db/schema.rb

@@ -95,13 +95,13 @@ Sequel.migration do
       String :response_body, :text=>true
       foreign_key :result_id, :results, :type=>String, :size=>255
       foreign_key :test_session_id, :test_sessions, :type=>String, :size=>255
-      String :"[:test_session_id, :name]"
       DateTime :created_at, :null=>false
       DateTime :updated_at, :null=>false
       
       index [:id]
       index [:result_id]
       index [:test_session_id]
+      index [:test_session_id, :name]
     end
     
     create_table(:result_outputs, :ignore_index_errors=>true) do

data/lib/inferno/dsl/assertions.rb

@@ -3,22 +3,43 @@ require_relative '../exceptions'
 module Inferno
   module DSL
     module Assertions
+      # Make an assertion
+      #
+      # @param test a value whose truthiness will determine whether the
+      #   assertion passes or fails
+      # @param message [String] failure message
       def assert(test, message = '')
         raise Exceptions::AssertionException, message unless test
       end
 
+      # @private
       def bad_response_status_message(expected, received)
         "Bad response status: expected #{Array.wrap(expected).join(', ')}, but received #{received}"
       end
 
+      # Check an response's status
+      #
+      # @param status [Integer, Array<Integer>] a single integer or an array of
+      #   integer status codes
+      # @param response [Hash]
       def assert_response_status(status, response: self.response)
         assert Array.wrap(status).include?(response[:status]), bad_response_status_message(status, response[:status])
       end
 
+      # @private
       def bad_resource_type_message(expected, received)
         "Bad resource type received: expected #{expected}, but received #{received}"
       end
 
+      # Check a FHIR resource's type
+      #
+      # @param resource_type [String, Symbol, Class]
+      # @param resource [FHIR::Model]
+      # @example
+      #   # The resource type can be a symbol, String, or FHIR::Model class
+      #   assert_resource_type(:capability_statement)
+      #   assert_resource_type('CapabilityStatement')
+      #   assert_resource_type(FHIR::CapabilityStatement)
       def assert_resource_type(resource_type, resource: self.resource)
         resource_type_name = normalize_resource_type(resource_type)
 
@@ -26,15 +47,48 @@ module Inferno
                bad_resource_type_message(resource_type_name, resource&.resourceType)
       end
 
+      # @private
       def invalid_resource_message(profile_url)
         "Resource does not conform to the profile: #{profile_url}"
       end
 
+      # Validate a FHIR resource
+      #
+      # @param resource [FHIR::Model]
+      # @param profile_url [String] url of the profile to validate against,
+      #   defaults to validating against the base FHIR resource
       def assert_valid_resource(resource: self.resource, profile_url: nil)
         assert resource_is_valid?(resource: resource, profile_url: profile_url),
                invalid_resource_message(profile_url)
       end
 
+      # Validate each entry of a Bundle
+      #
+      # @param bundle [FHIR::Bundle]
+      # @param resource_types
+      # [String,Symbol,FHIR::Model,Array<String,Symbol,FHIR::Model>,Hash] If a
+      #   string, symbol, or FHIR::Model is provided, only that resource type
+      #   will be validated. If an array of strings is provided, only those
+      #   resource types will be validated. If a hash is provided with resource
+      #   types as keys and profile urls (or nil) as values, only those resource
+      #   types will be validated against the provided profile url or the base
+      #   resource if nil.
+      # @example
+      #   # Only validate Patient bundle entries
+      #   assert_valid_bundle_entries(resource_types: 'Patient')
+      #
+      #   # Only valiadte Patient and Condition bundle entries
+      #   assert_valid_bundle_entries(resource_types: ['Patient', 'Condition'])
+      #
+      #   # Only validate Patient and Condition bundle entries. Validate Patient
+      #   # resources against the given profile, and Codition resources against the
+      #   # base FHIR Condition resource.
+      #   assert_valid_bundle_entries(
+      #     resource_types: {
+      #       'Patient': 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient',
+      #       'Condition': nil
+      #     }
+      #   )
       def assert_valid_bundle_entries(bundle: resource, resource_types: {})
         assert_resource_type('Bundle', resource: bundle)
 
@@ -56,6 +110,7 @@ module Inferno
         assert invalid_resources.empty?, invalid_bundle_entries_message(invalid_resources)
       end
 
+      # @private
       def invalid_bundle_entries_message(invalid_resources)
         identifier_strings =
           invalid_resources
@@ -64,6 +119,7 @@ module Inferno
         "The following bundle entries are invalid: #{identifier_strings}"
       end
 
+      # @private
       def normalize_resource_type(resource_type)
         if resource_type.is_a? Class
           resource_type.name.demodulize
@@ -72,6 +128,7 @@ module Inferno
         end
       end
 
+      # @private
       def normalize_types_to_check(resource_types)
         case resource_types
         when Hash
@@ -83,11 +140,39 @@ module Inferno
         end
       end
 
+      # Check for valid JSON
+      #
+      # @param maybe_json_string [String]
+      # @param message [String] extra failure message
       def assert_valid_json(maybe_json_string, message = '')
         assert JSON.parse(maybe_json_string)
       rescue JSON::ParserError
         assert false, "Invalid JSON. #{message}"
       end
+
+      # Check for a valid http/https uri
+      #
+      # @param uri [String]
+      # @param message [String] custom failure message
+      def assert_valid_http_uri(uri, message = '')
+        error_message = message.presence || "\"#{uri}\" is not a valid URI"
+        assert uri =~ /\A#{URI::DEFAULT_PARSER.make_regexp(['http', 'https'])}\z/, error_message
+      end
+
+      def assert_response_content_type(type, request: self.request)
+        header = request.response_header('Content-Type')
+        assert header.present?, no_content_type_message
+
+        assert header.value.start_with?(type), bad_content_type_message(type, header.value)
+      end
+
+      def no_content_type_message
+        'Response did not contain a `Content-Type` header.'
+      end
+
+      def bad_content_type_message(expected, received)
+        "Expected `Content-Type` to be `#{expected}`, but found `#{received}`"
+      end
     end
   end
 end

data/lib/inferno/dsl/configurable.rb

@@ -0,0 +1,126 @@
+module Inferno
+  module DSL
+    # This module contains the DSL for managing runnable configuration.
+    module Configurable
+      def self.extended(klass)
+        klass.extend Forwardable
+        klass.def_delegator 'self.class', :config
+      end
+
+      def config(new_configuration = {})
+        @config ||= Configuration.new
+
+        return @config if new_configuration.blank?
+
+        @config.apply(new_configuration)
+      end
+
+      # @private
+      class Configuration
+        attr_accessor :configuration
+
+        def initialize(configuration = {})
+          self.configuration = configuration
+        end
+
+        def apply(new_configuration)
+          config_to_apply =
+            if new_configuration.is_a? Configuration
+              new_configuration.configuration
+            else
+              new_configuration
+            end
+
+          self.configuration = configuration.deep_merge(config_to_apply)
+        end
+
+        def options
+          configuration[:options] ||= {}
+        end
+
+        ### Input Configuration ###
+
+        def inputs
+          configuration[:inputs] ||= {}
+        end
+
+        def add_input(identifier, new_config = {})
+          existing_config = input_config(identifier) || {}
+          inputs[identifier] = default_input_config(identifier).merge(existing_config, new_config)
+        end
+
+        def default_input_config(identifier)
+          { name: identifier, type: 'text' }
+        end
+
+        def input_config_exists?(identifier)
+          inputs.key? identifier
+        end
+
+        def input_config(identifier)
+          inputs[identifier]
+        end
+
+        def input_name(identifier)
+          inputs.dig(identifier, :name) || identifier
+        end
+
+        ### Output Configuration ###
+
+        def outputs
+          configuration[:outputs] ||= {}
+        end
+
+        def add_output(identifier)
+          return if output_config_exists?(identifier)
+
+          outputs[identifier] = default_output_config(identifier)
+        end
+
+        def default_output_config(identifier)
+          { name: identifier }
+        end
+
+        def output_config_exists?(identifier)
+          outputs.key? identifier
+        end
+
+        def output_config(identifier)
+          outputs[identifier]
+        end
+
+        def output_name(identifier)
+          outputs.dig(identifier, :name) || identifier
+        end
+
+        ### Request Configuration ###
+
+        def requests
+          configuration[:requests] ||= {}
+        end
+
+        def add_request(identifier)
+          return if request_config_exists?(identifier)
+
+          requests[identifier] = default_request_config(identifier)
+        end
+
+        def default_request_config(identifier)
+          { name: identifier }
+        end
+
+        def request_config_exists?(identifier)
+          requests.key? identifier
+        end
+
+        def request_config(identifier)
+          requests[identifier]
+        end
+
+        def request_name(identifier)
+          requests.dig(identifier, :name) || identifier
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_client.rb

@@ -35,7 +35,7 @@ module Inferno
     # @see Inferno::FHIRClientBuilder Documentation for the client
     #   configuration DSL
     module FHIRClient
-      # @api private
+      # @private
       def self.included(klass)
         klass.extend ClassMethods
         klass.extend Forwardable
@@ -54,7 +54,7 @@ module Inferno
           FHIRClientBuilder.new.build(self, self.class.fhir_client_definitions[client])
       end
 
-      # @api private
+      # @private
       def fhir_clients
         @fhir_clients ||= {}
       end
@@ -69,13 +69,15 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
+      # @param headers [Hash] custom headers for this operation
       # @return [Inferno::Entities::Request]
-      def fhir_operation(path, body: nil, client: :default, name: nil, **_options)
+      def fhir_operation(path, body: nil, client: :default, name: nil, headers: {})
         store_request('outgoing', name) do
-          headers = fhir_client(client).fhir_headers
-          headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
-          fhir_client(client).send(:post, path, body, headers)
+          operation_headers = fhir_client(client).fhir_headers
+          operation_headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
+          operation_headers.merge!(headers) if headers.present?
+
+          fhir_client(client).send(:post, path, body, operation_headers)
         end
       end
 
@@ -84,9 +86,8 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
       # @return [Inferno::Entities::Request]
-      def fhir_get_capability_statement(client: :default, name: nil, **_options)
+      def fhir_get_capability_statement(client: :default, name: nil)
         store_request('outgoing', name) do
           fhir_client(client).conformance_statement
           fhir_client(client).reply
@@ -100,9 +101,8 @@ module Inferno
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
       # @return [Inferno::Entities::Request]
-      def fhir_read(resource_type, id, client: :default, name: nil, **_options)
+      def fhir_read(resource_type, id, client: :default, name: nil)
         store_request('outgoing', name) do
           fhir_client(client).read(fhir_class_from_resource_type(resource_type), id)
         end
@@ -115,24 +115,30 @@ module Inferno
       # @param params [Hash] the search params
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
-      # @param _options [Hash] TODO
+      # @param search_method [Symbol] Use `:post` to search via POST
       # @return [Inferno::Entities::Request]
-      def fhir_search(resource_type, client: :default, params: {}, name: nil, **_options)
+      def fhir_search(resource_type, client: :default, params: {}, name: nil, search_method: :get)
+        search =
+          if search_method == :post
+            { body: params }
+          else
+            { parameters: params }
+          end
         store_request('outgoing', name) do
           fhir_client(client)
-            .search(fhir_class_from_resource_type(resource_type), search: { parameters: params })
+            .search(fhir_class_from_resource_type(resource_type), { search: search })
         end
       end
 
       # @todo Make this a FHIR class method? Something like
       #   FHIR.class_for(resource_type)
-      # @api private
+      # @private
       def fhir_class_from_resource_type(resource_type)
         FHIR.const_get(resource_type.to_s.camelize)
       end
 
       module ClassMethods
-        # @api private
+        # @private
         def fhir_client_definitions
           @fhir_client_definitions ||= {}
         end

data/lib/inferno/dsl/fhir_client_builder.rb

@@ -6,7 +6,7 @@ module Inferno
     class FHIRClientBuilder
       attr_accessor :runnable
 
-      # @api private
+      # @private
       def build(runnable, block)
         self.runnable = runnable
         instance_exec(self, &block)
@@ -56,14 +56,14 @@ module Inferno
         @headers ||= headers
       end
 
-      # @api private
+      # @private
       def method_missing(name, *args, &block)
         return runnable.call(name, *args, &block) if runnable.respond_to? name
 
         super
       end
 
-      # @api private
+      # @private
       def respond_to_missing?(name)
         runnable.respond_to?(name) || super
       end