inferno_core 0.0.1

data/lib/inferno/dsl/http_client.rb

@@ -0,0 +1,122 @@
+require_relative 'request_storage'
+
+module Inferno
+  module DSL
+    # This module contains the HTTP DSL available to test writers.
+    #
+    # @example
+    #   class MyTestGroup < Inferno::TestGroup
+    #     # create a "default" client for a group
+    #     http_client do
+    #       url 'https://example.com/'
+    #     end
+    #
+    #     test :some_test do
+    #       run do
+    #         # performs a GET to https://example.com
+    #         get
+    #         # performs a GET to https://example.com/abc
+    #          get('abc')
+    #
+    #         request  # the most recent request
+    #         response # the most recent response
+    #         requests # all of the requests which have been made in this test
+    #       end
+    #     end
+    #   end
+    # @see Inferno::FHIRClientBuilder Documentation for the client
+    #   configuration DSL
+    module HTTPClient
+      # @api private
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.include RequestStorage
+      end
+
+      # Return a previously defined HTTP client
+      #
+      # @param client [Symbol] the name of the client
+      # @return [Faraday::Connection]
+      # @see Inferno::HTTPClientBuilder
+      def http_client(client = :default)
+        return http_clients[client] if http_clients[client]
+
+        definition = self.class.http_client_definitions[client]
+        return nil if definition.nil?
+
+        http_clients[client] = HTTPClientBuilder.new.build(self, definition)
+      end
+
+      # @api private
+      def http_clients
+        @http_clients ||= {}
+      end
+
+      # Perform an HTTP GET request
+      #
+      # @param url [String] if this request is using a defined client, this will
+      #   be appended to the client's url. Must be an absolute url for requests
+      #   made without a defined client
+      # @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 get(url = '', client: :default, name: nil, **_options)
+        store_request('outgoing', name) do
+          client = http_client(client)
+
+          if client
+            client.get(url)
+          elsif url.match?(%r{\Ahttps?://})
+            Faraday.get(url)
+          else
+            raise StandardError, 'Must use an absolute url or define an HTTP client with a base url'
+          end
+        end
+      end
+
+      # Perform an HTTP POST request
+      #
+      # @param url [String] if this request is using a defined client, this will
+      #   be appended to the client's url. Must be an absolute url for requests
+      #   made without a defined client
+      # @param body [String]
+      # @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 post(url = '', body: nil, client: :default, name: nil, **_options)
+        store_request('outgoing', name) do
+          client = http_client(client)
+
+          if client
+            client.post(url, body)
+          elsif url.match?(%r{\Ahttps?://})
+            Faraday.post(url, body)
+          else
+            raise StandardError, 'Must use an absolute url or define an HTTP client with a base url'
+          end
+        end
+      end
+
+      module ClassMethods
+        # @api private
+        def http_client_definitions
+          @http_client_definitions ||= {}
+        end
+
+        # Define a HTTP client to be used by a Runnable.
+        #
+        # @param name [Symbol] a name used to reference this particular client
+        # @param block a block to configure the client
+        # @see Inferno::HTTPClientBuilder Documentation for the client
+        #   configuration DSL
+        def http_client(name = :default, &block)
+          http_client_definitions[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/http_client_builder.rb

@@ -0,0 +1,54 @@
+module Inferno
+  module DSL
+    # This module contains the HTTP DSL available to test writers.
+    class HTTPClientBuilder
+      attr_accessor :runnable
+
+      # @api private
+      def build(runnable, block)
+        self.runnable = runnable
+        instance_exec(self, &block)
+
+        params = { url: url }
+        params.merge!(headers: headers) if headers
+
+        Faraday.new(params)
+      end
+
+      # Define the base url for an HTTP client. A string or symbol can be
+      # provided. A string is interpreted as a url. A symbol is interpreted as
+      # the name of an input to the Runnable.
+      #
+      # @param url [String, Symbol]
+      # @return [void]
+      def url(url = nil)
+        @url ||=
+          if url.is_a? Symbol
+            runnable.send(url)
+          else
+            url
+          end
+      end
+
+      # Define custom headers for a client
+      #
+      # @param headers [Hash]
+      # @return [void]
+      def headers(headers = nil)
+        @headers ||= headers
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        return runnable.call(name, *args, &block) if runnable.respond_to? name
+
+        super
+      end
+
+      # @api private
+      def respond_to_missing?(name)
+        runnable.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/inferno/dsl/request_storage.rb

@@ -0,0 +1,101 @@
+module Inferno
+  module DSL
+    # This module handles storing and retrieving requests/responses made by
+    # FHIR/HTTP clients
+    module RequestStorage
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      # Returns the FHIR/HTTP requests that have been made in this `Test`
+      #
+      # @return [Array<Inferno::Entities::Request>]
+      def requests
+        @requests ||= []
+      end
+
+      # Returns the most recent FHIR/HTTP request
+      #
+      # @return [Inferno::Entities::Request]
+      def request
+        requests.last
+      end
+
+      # Returns the response from the most recent FHIR/HTTP request
+      #
+      # @return [Hash, nil]
+      def response
+        request&.response
+      end
+
+      # Returns the FHIR resource from the response to the most recent FHIR
+      # request
+      #
+      # @return [FHIR::Model, nil]
+      def resource
+        request&.resource
+      end
+
+      # TODO: do a check in the test runner
+      def named_request(name)
+        requests.find { |request| request.name == name.to_sym }
+      end
+
+      # @api private
+      def store_request(direction, name = nil, &block)
+        response = block.call
+
+        request =
+          if response.is_a? FHIR::ClientReply
+            Entities::Request.from_fhir_client_reply(
+              response, direction: direction, name: name, test_session_id: test_session_id
+            )
+          else
+            Entities::Request.from_http_response(
+              response, direction: direction, name: name, test_session_id: test_session_id
+            )
+          end
+
+        requests << request
+        request
+      end
+
+      # @api private
+      def load_named_requests
+        requests_repo = Inferno::Repositories::Requests.new
+        self.class.named_requests_used.map do |request_name|
+          request = requests_repo.find_named_request(test_session_id, request_name)
+          raise StandardError, "Unable to find '#{request_name}' request" if request.nil?
+
+          requests << request
+        end
+      end
+
+      module ClassMethods
+        # @api private
+        def named_requests_made
+          @named_requests_made ||= []
+        end
+
+        # @api private
+        def named_requests_used
+          @named_requests_used ||= []
+        end
+
+        # Specify the named requests made by a test
+        #
+        # @param *names [Symbol] one or more Symbols
+        def makes_request(*names)
+          named_requests_made.concat(names)
+        end
+
+        # Specify the named requests used by a test
+        #
+        # @param *names [Symbol] one or more Symbols
+        def uses_request(*names)
+          named_requests_used.concat(names)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/results.rb

@@ -0,0 +1,54 @@
+module Inferno
+  module DSL
+    # This module contains methods to set test results.
+    module Results
+      # Halt execution of the current test and mark it as passed.
+      #
+      # @param message [String]
+      def pass(message = '')
+        raise Exceptions::PassException, message
+      end
+
+      # Halt execution of the current test and mark it as passed if a condition
+      # is true.
+      #
+      # @param test [Boolean]
+      # @param message [String]
+      def pass_if(test, message = '')
+        raise Exceptions::PassException, message if test
+      end
+
+      # Halt execution of the current test and mark it as skipped.
+      #
+      # @param message [String]
+      def skip(message = '')
+        raise Exceptions::SkipException, message
+      end
+
+      # Halt execution of the current test and mark it as skipped if a condition
+      # is true.
+      #
+      # @param test [Boolean]
+      # @param message [String]
+      def skip_if(test, message = '')
+        raise Exceptions::SkipException, message if test
+      end
+
+      # Halt execution of the current test and mark it as omitted.
+      #
+      # @param message [String]
+      def omit(message = '')
+        raise Exceptions::OmitException, message
+      end
+
+      # Halt execution of the current test and mark it as omitted if a condition
+      # is true.
+      #
+      # @param test [Boolean]
+      # @param message [String]
+      def omit_if(test, message = '')
+        raise Exceptions::OmitException, message if test
+      end
+    end
+  end
+end

data/lib/inferno/dsl/runnable.rb

@@ -0,0 +1,250 @@
+module Inferno
+  module DSL
+    # This module contains the DSL for defining child entities in the test
+    # definition framework.
+    module Runnable
+      attr_accessor :parent
+
+      # When a class (e.g. TestSuite/TestGroup) uses this module, set it up
+      # so that subclassing it works correctly.
+      # - add the subclass to the relevant repository when it is created
+      # - copy the class instance variables from the superclass
+      # - add a hook to the subclass so that its subclasses do the same
+      # @api private
+      def self.extended(extending_class)
+        super
+
+        extending_class.define_singleton_method(:inherited) do |subclass|
+          copy_instance_variables(subclass)
+
+          # Whenever the definition of a Runnable class ends, keep track of the
+          # file it came from. Once the Suite loader successfully loads a file,
+          # it will add all of the Runnable classes from that file to the
+          # appropriate repositories.
+          TracePoint.trace(:end) do |trace|
+            if trace.self == subclass
+              subclass.add_self_to_repository
+              trace.disable
+            end
+          end
+        end
+      end
+
+      # Class instance variables are used to hold the metadata for Runnable
+      # classes. When inheriting from a Runnable class, these class instance
+      # variables need to be copied. Any child Runnable classes will themselves
+      # need to be subclassed so that their parent can be updated.
+      # @api private
+      def copy_instance_variables(subclass)
+        instance_variables.each do |variable|
+          next if [:@id, :@groups, :@tests, :@parent, :@children].include?(variable)
+
+          subclass.instance_variable_set(variable, instance_variable_get(variable).dup)
+        end
+
+        child_types.each do |child_type|
+          new_children = send(child_type).map do |child|
+            Class.new(child).tap do |subclass_child|
+              subclass_child.parent = subclass
+            end
+          end
+
+          subclass.instance_variable_set(:"@#{child_type}", new_children)
+          subclass.children.concat(new_children)
+        end
+      end
+
+      # @api private
+      def add_self_to_repository
+        repository.insert(self)
+      end
+
+      # An instance of the repository for the class using this module
+      def repository
+        nil
+      end
+
+      # This method defines a child entity. Classes using this module should
+      # alias the method name they wish to use to define child entities to this
+      # method.
+      # @api private
+      def define_child(*args, &block)
+        hash_args = process_args(args)
+
+        klass = create_child_class(hash_args)
+
+        klass.parent = self
+
+        child_metadata[:collection] << klass
+        children << klass
+
+        configure_child_class(klass, hash_args)
+
+        handle_child_definition_block(klass, &block)
+
+        klass.add_self_to_repository
+
+        klass
+      end
+
+      # @api private
+      def process_args(args)
+        hash_args =
+          if args[0].is_a? Hash
+            args[0]
+          elsif args[1].is_a? Hash
+            args[1]
+          else
+            {}
+          end
+
+        hash_args[:title] = args[0] if args[0].is_a? String
+
+        hash_args
+      end
+
+      # @api private
+      def child_metadata(metadata = nil)
+        @child_metadata = metadata if metadata
+        @child_metadata
+      end
+
+      # @api private
+      def create_child_class(hash_args)
+        superclass_id = hash_args.delete :from
+
+        return Class.new(child_metadata[:class]) if superclass_id.blank?
+
+        superclass = child_metadata[:repo].find(superclass_id)
+
+        raise Exceptions::ParentNotLoadedException.new(child_metadata[:class], superclass_id) unless superclass
+
+        Class.new(superclass)
+      end
+
+      # @api private
+      def configure_child_class(klass, hash_args) # rubocop:disable Metrics/CyclomaticComplexity
+        inputs.each do |input_definition|
+          next if klass.inputs.include? input_definition
+
+          klass.input input_definition
+        end
+
+        outputs.each do |output_definition|
+          next if klass.outputs.include? output_definition
+
+          klass.output output_definition
+        end
+
+        new_fhir_client_definitions = klass.instance_variable_get(:@fhir_client_definitions) || {}
+        fhir_client_definitions.each do |name, definition|
+          next if new_fhir_client_definitions.include? name
+
+          new_fhir_client_definitions[name] = definition.dup
+        end
+        klass.instance_variable_set(:@fhir_client_definitions, new_fhir_client_definitions)
+
+        new_http_client_definitions = klass.instance_variable_get(:@http_client_definitions) || {}
+        http_client_definitions.each do |name, definition|
+          next if new_http_client_definitions.include? name
+
+          new_http_client_definitions[name] = definition.dup
+        end
+        klass.instance_variable_set(:@http_client_definitions, new_http_client_definitions)
+
+        hash_args.each do |key, value|
+          klass.send(key, *value)
+        end
+
+        klass.children.each do |child_class|
+          klass.configure_child_class(child_class, {})
+          child_class.add_self_to_repository
+        end
+      end
+
+      # @api private
+      def handle_child_definition_block(klass, &block)
+        klass.class_eval(&block) if block_given?
+      end
+
+      def id(new_id = nil)
+        return @id if new_id.nil? && @id.present?
+
+        prefix =
+          if parent
+            "#{parent.id}-"
+          else
+            ''
+          end
+
+        @base_id = new_id || @base_id || default_id
+
+        @id = "#{prefix}#{@base_id}"
+      end
+
+      def title(new_title = nil)
+        return @title if new_title.nil?
+
+        @title = new_title
+      end
+
+      def description(new_description = nil)
+        return @description if new_description.nil?
+
+        @description = new_description
+      end
+
+      # Define inputs
+      #
+      # @param inputs [Symbol]
+      # @return [void]
+      # @example
+      #   input :patient_id, :bearer_token
+      def input(*input_definitions)
+        inputs.concat(input_definitions)
+      end
+
+      # Define outputs
+      #
+      # @param output_definitions [Symbol]
+      # @return [void]
+      # @example
+      #   output :patient_id, :bearer_token
+      def output(*output_definitions)
+        outputs.concat(output_definitions)
+      end
+
+      # @api private
+      def default_id
+        to_s
+      end
+
+      # @api private
+      def inputs
+        @inputs ||= []
+      end
+
+      # @api private
+      def outputs
+        @outputs ||= []
+      end
+
+      def child_types
+        return [] if ancestors.include? Inferno::Entities::Test
+        return [:groups] if ancestors.include? Inferno::Entities::TestSuite
+
+        [:groups, :tests]
+      end
+
+      def children
+        @children ||= []
+      end
+
+      def validator_url(url = nil)
+        return @validator_url ||= parent&.validator_url if url.nil?
+
+        @validator_url = url
+      end
+    end
+  end
+end