inferno_core 0.0.1

data/lib/inferno/entities.rb

@@ -0,0 +1,19 @@
+require_relative 'entities/attributes'
+require_relative 'entities/entity'
+require_relative 'entities/header'
+require_relative 'entities/message'
+require_relative 'entities/request'
+require_relative 'entities/result'
+require_relative 'entities/test'
+require_relative 'entities/test_group'
+require_relative 'entities/test_input'
+require_relative 'entities/test_run'
+require_relative 'entities/test_session'
+require_relative 'entities/test_suite'
+
+module Inferno
+  # Entities are domain objects whose identity is based on an `id`. Entities
+  # don't know anything about persistence, which is handled by Repositories.
+  module Entities
+  end
+end

data/lib/inferno/entities/attributes.rb

@@ -0,0 +1,9 @@
+module Inferno
+  module Entities
+    module Attributes
+      def self.included(klass)
+        klass.attr_accessor(*klass::ATTRIBUTES)
+      end
+    end
+  end
+end

data/lib/inferno/entities/entity.rb

@@ -0,0 +1,15 @@
+module Inferno
+  module Entities
+    class Entity
+      def initialize(params, attributes)
+        attributes.each { |name| instance_variable_set("@#{name}", params[name]) }
+      end
+
+      def to_hash
+        self.class::ATTRIBUTES.each_with_object({}) do |attribute, hash|
+          hash[attribute] = send(attribute)
+        end.compact
+      end
+    end
+  end
+end

data/lib/inferno/entities/header.rb

@@ -0,0 +1,42 @@
+module Inferno
+  module Entities
+    # A `Header` represents an HTTP request/response header
+    #
+    # @attr_reader [String] id of the header
+    # @attr_reader [String] request_id index of the HTTP request
+    # @attr_reader [String] name header name
+    # @attr_reader [String] value header value
+    # @attr_reader [String] type request/response
+    # @attr_reader [Time] created_at
+    # @attr_reader [Time] updated_at
+    class Header < Entity
+      ATTRIBUTES = [:id, :request_id, :name, :type, :value, :created_at, :updated_at].freeze
+
+      include Inferno::Entities::Attributes
+
+      def initialize(params)
+        super(params, ATTRIBUTES)
+      end
+
+      def request?
+        type == 'request'
+      end
+
+      def response?
+        type == 'response'
+      end
+
+      def to_hash
+        {
+          id: id,
+          request_id: request_id,
+          type: type,
+          name: name,
+          value: value,
+          created_at: created_at,
+          updated_at: updated_at
+        }.compact
+      end
+    end
+  end
+end

data/lib/inferno/entities/message.rb

@@ -0,0 +1,22 @@
+module Inferno
+  module Entities
+    # A `Message` represents a message generated during a test.
+    #
+    # @attr_reader [String] id of the message
+    # @attr_reader [String] index of the message. Used for ordering.
+    # @attr_reader [String] result_id
+    # @attr_reader [Inferno::Entities::Result] result
+    # @attr_reader [String] type
+    # @attr_reader [String] message
+    class Message < Entity
+      ATTRIBUTES = [:id, :index, :message, :result_id, :result, :type, :created_at, :updated_at].freeze
+      TYPES = ['error', 'warning', 'info'].freeze
+
+      include Inferno::Entities::Attributes
+
+      def initialize(params)
+        super(params, ATTRIBUTES)
+      end
+    end
+  end
+end

data/lib/inferno/entities/request.rb

@@ -0,0 +1,166 @@
+module Inferno
+  module Entities
+    # A `Request` represents a request and response issued during a test.
+    #
+    # @attr_reader [String] id of the request
+    # @attr_reader [String] index of the request. Used for ordering.
+    # @attr_reader [String] verb http verb
+    # @attr_reader [String] url request url
+    # @attr_reader [String] direction incoming/outgoing
+    # @attr_reader [String] name name for the request
+    # @attr_reader [String] status http response status code
+    # @attr_reader [String] request_body body of the http request
+    # @attr_reader [String] response_body body of the http response
+    # @attr_reader [Array<Inferno::Entities::Header>] headers http
+    #   request/response headers
+    # @attr_reader [String] result_id id of the result for this request
+    # @attr_reader [String] test_session_id id of the test session for this request
+    # @attr_reader [Time] created_at creation timestamp
+    # @attr_reader [Time] updated_at update timestamp
+    class Request < Entity
+      ATTRIBUTES = [
+        :id, :index, :verb, :url, :direction, :name, :status,
+        :request_body, :response_body, :result_id, :test_session_id, :created_at,
+        :updated_at, :headers
+      ].freeze
+      SUMMARY_FIELDS = [
+        :id, :index, :url, :verb, :direction, :name, :status, :result_id, :created_at, :updated_at
+      ].freeze
+
+      include Attributes
+
+      def initialize(params)
+        super(params, ATTRIBUTES - [:headers, :name])
+
+        @name = params[:name]&.to_sym
+        @headers = params[:headers]&.map { |header| header.is_a?(Hash) ? Header.new(header) : header } || []
+      end
+
+      # Find a response header
+      #
+      # @param name [String] the header name
+      # @return [Inferno::Entities::RequestHeader, nil]
+      def response_header(name)
+        response_headers.find { |header| header.name == name.downcase }
+      end
+
+      # Find a request header
+      #
+      # @param name [String] the header name
+      # @return [Inferno::Entities::RequestHeader, nil]
+      def request_header(name)
+        request_headers.find { |header| header.name == name.downcase }
+      end
+
+      # All of the request headers
+      #
+      # @return [Array<Inferno::Entities::RequestHeader>]
+      def request_headers
+        headers.select(&:request?)
+      end
+
+      # All of the response headers
+      #
+      # @return [Array<Inferno::Entities::RequestHeader>]
+      def response_headers
+        headers.select(&:response?)
+      end
+
+      # Return a hash of the request parameters
+      #
+      # @return [Hash]
+      def request
+        {
+          verb: verb,
+          url: url,
+          headers: request_headers,
+          body: request_body
+        }
+      end
+
+      # Return a hash of the response parameters
+      #
+      # @return [Hash]
+      def response
+        {
+          status: status,
+          headers: response_headers,
+          body: response_body
+        }
+      end
+
+      # @api private
+      def to_hash
+        {
+          id: id,
+          verb: verb,
+          url: url,
+          direction: direction,
+          status: status,
+          name: name,
+          request_body: request_body,
+          response_body: response_body,
+          result_id: result_id,
+          test_session_id: test_session_id,
+          request_headers: request_headers.map(&:to_hash),
+          response_headers: response_headers.map(&:to_hash),
+          created_at: created_at,
+          updated_at: updated_at
+        }.compact
+      end
+
+      # Return the FHIR resource from the response body.
+      #
+      # @return [FHIR::Model]
+      def resource
+        FHIR.from_contents(response_body)
+      end
+
+      class << self
+        # @api private
+        def from_http_response(response, test_session_id:, direction: 'outgoing', name: nil)
+          request_headers =
+            response.env.request_headers
+              .map { |header_name, value| Header.new(name: header_name.downcase, value: value, type: 'request') }
+          response_headers =
+            response.headers
+              .map { |header_name, value| Header.new(name: header_name.downcase, value: value, type: 'response') }
+
+          new(
+            verb: response.env.method,
+            url: response.env.url.to_s,
+            direction: direction,
+            name: name,
+            status: response.status,
+            request_body: response.env.request_body,
+            response_body: response.body,
+            test_session_id: test_session_id,
+            headers: request_headers + response_headers
+          )
+        end
+
+        # @api private
+        def from_fhir_client_reply(reply, test_session_id:, direction: 'outgoing', name: nil)
+          request = reply.request
+          response = reply.response
+          request_headers = request[:headers]
+            .map { |header_name, value| Header.new(name: header_name.downcase, value: value, type: 'request') }
+          response_headers = response[:headers]
+            .map { |header_name, value| Header.new(name: header_name.downcase, value: value, type: 'response') }
+
+          new(
+            verb: request[:method],
+            url: request[:url],
+            direction: direction,
+            name: name,
+            status: response[:code].to_i,
+            request_body: request[:payload],
+            response_body: response[:body],
+            test_session_id: test_session_id,
+            headers: request_headers + response_headers
+          )
+        end
+      end
+    end
+  end
+end

data/lib/inferno/entities/result.rb

@@ -0,0 +1,49 @@
+module Inferno
+  module Entities
+    # A `Result` represents the result of running a `Test`, `TestGroup`,
+    # or `TestSuite`
+    #
+    # @attr_reader [String] id id of the session
+    # @attr_reader [Time] created_at creation timestamp
+    # @attr_reader [Time] updated_at update timestamp
+    # @attr_reader [String] reference_type type of entity this result belongs to
+    #   (`Test`, `TestGroup`, or `TestSuite`)
+    # @attr_reader [String, nil] test_id id of the `Test` this result belongs to
+    # @attr_reader [Test, nil] test the `Test` this result belongs to
+    # @attr_reader [String, nil] test_group_id id of the `TestGroup` this result belongs to
+    # @attr_reader [TestGroup, nil] test_group the `TestGroup` this result belongs to
+    # @attr_reader [String, nil] test_suite_id id of the `TestSuite` this result belongs to
+    # @attr_reader [TestSuite, nil] test_suite the `TestSuite` this result belongs to
+    # @attr_reader [String] result the result (`pass`, `fail`, `skip`, `omit`,
+    #   `error`, `running`, `wait`, `cancel`)
+    # @attr_reader [String] result_message summary message for this result
+    # @attr_reader [String] test_run_id the `TestRun` this result belongs to
+    # @attr_reader [String] test_session_id the `TestSession` this result
+    #   belongs to
+    # @attr_reader [Array<Inferno::Entities::Message>] messages additional
+    #   messages for this result
+    # @attr_reader [Array<Inferno::Entities::Request>] request_summaries
+    #   summaries of the requests associated with this result
+    class Result < Entity
+      ATTRIBUTES = [
+        :id, :created_at, :updated_at, :test_id, :test, :test_group_id,
+        :test_group, :test_suite_id, :test_suite, :test_run_id,
+        :test_session_id, :result, :result_message, :messages, :requests
+      ].freeze
+      RESULT_OPTIONS = ['cancel', 'wait', 'running', 'error', 'fail', 'skip', 'omit', 'pass'].freeze
+
+      include Inferno::Entities::Attributes
+
+      def initialize(params)
+        super(params, ATTRIBUTES - [:messages, :requests])
+
+        @messages = (params[:messages] || []).map { |message| Message.new(message) }
+        @requests = (params[:requests] || []).map { |request| Request.new(request) }
+      end
+
+      def runnable
+        test || test_group || test_suite
+      end
+    end
+  end
+end

data/lib/inferno/entities/test.rb

@@ -0,0 +1,173 @@
+require_relative '../dsl'
+require_relative '../repositories/tests'
+
+module Inferno
+  module Entities
+    class Test
+      extend Forwardable
+      include DSL
+
+      def_delegators 'self.class', :title, :id, :block, :inputs, :outputs
+
+      attr_accessor :result_message
+      attr_reader :inputs, :test_session_id
+
+      def initialize(**params)
+        @inputs = params[:inputs]
+        @test_session_id = params[:test_session_id]
+      end
+
+      def messages
+        @messages ||= []
+      end
+
+      def add_message(type, message)
+        messages << { type: type.to_s, message: message }
+      end
+
+      # Set output values. Once set, these values will be available to any
+      # subsequent tests.
+      #
+      # @param outputs [Hash]
+      # @return [void]
+      # @example
+      #   output(patient_id: '5', bearer_token: 'ABC')
+      def output(outputs)
+        outputs.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Add an informational message to the results of a test. If passed a
+      # block, a failed assertion will become an info message and test execution
+      # will continue.
+      #
+      # @param message [String]
+      # @return [void]
+      # @example
+      #   # Add an info message
+      #   info 'This message will be added to the test results'
+      #
+      #   # The message for the failed assertion will be treated as an info
+      #   # message. Test exection will continue.
+      #   info { assert false == true }
+      def info(message = nil)
+        unless block_given?
+          add_message('info', message) unless message.nil?
+          return
+        end
+
+        yield
+      rescue Exceptions::AssertionException => e
+        add_message('info', e.message)
+      end
+
+      # Add a warning message to the results of a test. If passed a block, a
+      # failed assertion will become a warning message and test execution will
+      # continue.
+      #
+      # @param message [String]
+      # @return [void]
+      # @example
+      #   # Add a warning message
+      #   warning 'This message will be added to the test results'
+      #
+      #   # The message for the failed assertion will be treated as a warning
+      #   # message. Test exection will continue.
+      #   warning { assert false == true }
+      def warning(message = nil)
+        unless block_given?
+          add_message('warning', message) unless message.nil?
+          return
+        end
+
+        yield
+      rescue Exceptions::AssertionException => e
+        add_message('warning', e.message)
+      end
+
+      def method_missing(name, *args, &block)
+        parent_instance = self.class.parent&.new
+        if parent_instance.respond_to?(name)
+          parent_instance.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _include_private = false)
+        self.class.parent&.new&.respond_to?(name)
+      end
+
+      class << self
+        # Define inputs for this Test
+        #
+        # @param inputs [Symbol]
+        # @return [void]
+        # @example
+        #   input :patient_id, :bearer_token
+        def input(*input_definitions)
+          super
+
+          input_definitions.each do |input|
+            attr_reader input
+          end
+        end
+
+        # Define outputs for this Test
+        #
+        # @param output_definitions [Symbol]
+        # @return [void]
+        # @example
+        #   output :patient_id, :bearer_token
+        def output(*output_definitions)
+          super
+
+          output_definitions.each do |output|
+            attr_accessor output
+          end
+        end
+
+        def repository
+          Inferno::Repositories::Tests.new
+        end
+
+        def block(&block)
+          return @block unless block_given?
+
+          @block = block
+        end
+
+        alias run block
+
+        def default_id
+          return name if name.present?
+
+          suffix = parent ? (parent.tests.find_index(self) + 1).to_s.rjust(2, '0') : SecureRandom.uuid
+          "Test#{suffix}"
+        end
+
+        def reference_hash
+          {
+            test_id: id
+          }
+        end
+
+        def method_missing(name, *args, &block)
+          parent_instance = parent&.new
+          if parent_instance.respond_to?(name)
+            parent_instance.send(name, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, _include_private = false)
+          parent&.new&.respond_to?(name)
+        end
+      end
+    end
+  end
+
+  Test = Entities::Test
+end