inferno_core 0.0.1

data/lib/inferno/repositories/in_memory_repository.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module Inferno
+  module Repositories
+    class InMemoryRepository
+      extend Forwardable
+
+      def_delegators 'self.class', :all, :all_by_id
+
+      def insert(klass)
+        all << klass
+      end
+
+      def find(id)
+        all_by_id[id.to_s]
+      end
+
+      def exists?(id)
+        all_by_id.include? id
+      end
+
+      class << self
+        def all
+          @all ||= []
+        end
+
+        # @api private
+        def all_by_id
+          @all_by_id ||= {}
+          @all_by_id.length == all.length ? @all_by_id : index_by_id
+        end
+
+        def index_by_id
+          @all_by_id = {}
+          all.each { |klass| @all_by_id[klass.id] = klass }
+          @all_by_id
+        end
+      end
+    end
+  end
+end

data/lib/inferno/repositories/messages.rb

@@ -0,0 +1,35 @@
+module Inferno
+  module Repositories
+    class Messages < Repository
+      def messages_for_result(result_id)
+        self.class::Model
+          .order(:index)
+          .where(result_id: result_id)
+          .to_a
+          .map!(&:to_json_data)
+          .each(&:deep_symbolize_keys!)
+          .map! { |result| build_entity(result) }
+      end
+
+      class Model < Sequel::Model(db)
+        many_to_one :result, class: 'Inferno::Repositories::Results::Model', key: :result_id
+
+        def before_create
+          self.id = SecureRandom.uuid
+          time = Time.now
+          self.created_at ||= time
+          self.updated_at ||= time
+          super
+        end
+
+        def validate
+          super
+          types = Entities::Message::TYPES
+          errors.add(:message, 'must be present') if message.blank?
+          errors.add(:type, 'must be present') if type.blank?
+          errors.add(:type, "'#{type}' is invalid. Must be one of: #{types.join(', ')}") unless types.include?(type)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/repositories/repository.rb

@@ -0,0 +1,106 @@
+module Inferno
+  module Repositories
+    # Base class for repositories. Subclass and override methods as
+    # needed.
+    #
+    # @abstract
+    class Repository
+      extend Forwardable
+
+      def_delegators 'self.class', :db, :table_name
+
+      # Return the db connection for this repository.
+      def self.db
+        Application['db.connection'][table_name]
+      end
+
+      # Return the name of the database table for this repository. Override if
+      # the table name is not the snake case version of the name of the
+      # repository class.
+      #
+      # @return [String]
+      def self.table_name
+        name.demodulize.underscore.to_sym
+      end
+
+      # Return the name of the entity class which will be instantiated by a
+      # repository. Override if the entity class name is not the singular
+      # version of the repository name.
+      #
+      # @return [Class]
+      def entity_class_name
+        self.class.name.demodulize.singularize
+      end
+
+      # Return the class of the entity which will be instantiated by a
+      # repository. Override if the entity class is not in the
+      # `Inferno::Entities` namespace.
+      #
+      # @return [Class]
+      def entity_class
+        Entities.const_get(entity_class_name)
+      end
+
+      # Find a database record by id, and instantiate an entity from that
+      # record.
+      #
+      # @param id [String]
+      # @return [Inferno::Entities] an instance of the class returned by
+      #   `#entity_class`
+      def find(id)
+        result = self.class::Model.find(id: id)
+        return result if result.nil?
+
+        build_entity(result.to_hash)
+      end
+
+      def add_non_db_entities(hash)
+        if hash.include? :test_id
+          hash[:test] = Tests.new.find(hash[:test_id])
+        elsif hash.include? :test_group_id
+          hash[:test_group] = TestGroups.new.find(hash[:test_group_id])
+        elsif hash.include? :test_suite_id
+          hash[:test_suite] = TestSuites.new.find(hash[:test_suite_id])
+        end
+      end
+
+      # Create a new record in the database.
+      #
+      # @param params [Hash]
+      # @return [Inferno::Entities] an instance of the entity for this repo
+      # @example
+      #   repo = Inferno::Repositories::SomeEntities.new
+      #   begin
+      #     result = repo.create(key1: 'value1', key2: 'value2')
+      #   rescue Sequel::ValidationFailed => e
+      #     # handle error
+      #   end
+      def create(params)
+        result = self.class::Model.create(db_params(params))
+        build_entity(result.to_hash.merge(handle_non_db_params(params)))
+      end
+
+      # Creates an instance of the entity associated with this repository.
+      # Override if any special logic is required to create the entity.
+      #
+      # @param params [Hash]
+      # @return [Object] an instance of `#entity_class`
+      def build_entity(params)
+        add_non_db_entities(params)
+        entity_class.new(params)
+      end
+
+      def db_params(params)
+        params.slice(*self.class::Model.columns)
+      end
+
+      def non_db_params(params)
+        params.reject { |key, _value| self.class::Model.columns.include? key }
+      end
+
+      def handle_non_db_params(params)
+        non_db_params(params)
+      end
+    end
+  end
+end

data/lib/inferno/repositories/requests.rb

@@ -0,0 +1,89 @@
+module Inferno
+  module Repositories
+    class Requests < Repository
+      include Import[headers_repo: 'repositories.headers']
+
+      def create(params)
+        request = self.class::Model.create(db_params(params))
+
+        request_headers = (params[:request_headers] || []).map do |header|
+          headers_repo.create(header.merge(request_id: request.index, type: 'request'))
+        end
+        response_headers = (params[:response_headers] || []).map do |header|
+          headers_repo.create(header.merge(request_id: request.index, type: 'response'))
+        end
+
+        headers = request_headers + response_headers
+
+        build_entity(
+          request.to_hash
+            .merge(headers: headers)
+            .merge(non_db_params(params))
+        )
+      end
+
+      def find(id)
+        result =
+          self.class::Model
+            .where(id: id)
+            .select(*entity_class::SUMMARY_FIELDS)
+            .to_a
+        return nil if result.blank?
+
+        build_entity(result.first.to_hash)
+      end
+
+      def find_full_request(id)
+        result =
+          self.class::Model
+            .find(id: id)
+            .to_json_data(json_serializer_options)
+            .deep_symbolize_keys!
+
+        build_entity(result)
+      end
+
+      def find_named_request(test_session_id, name)
+        results =
+          self.class::Model
+            .where(test_session_id: test_session_id, name: name.to_s)
+            .map { |model| model.to_json_data(json_serializer_options) }
+        return nil if results.blank?
+
+        result = results.reduce { |max, current| current['index'] > max['index'] ? current : max }
+        result.deep_symbolize_keys!
+
+        build_entity(result)
+      end
+
+      def requests_for_result(result_id)
+        self.class::Model
+          .order(:index)
+          .where(result_id: result_id)
+          .select(*entity_class::SUMMARY_FIELDS)
+          .to_a
+          .map(&:to_hash)
+          .map! { |result| build_entity(result) }
+      end
+
+      def json_serializer_options
+        {
+          include: :headers
+        }
+      end
+
+      class Model < Sequel::Model(db)
+        many_to_one :result, class: 'Inferno::Repositories::Results::Model', key: :result_id
+        one_to_many :headers, class: 'Inferno::Repositories::Headers::Model', key: :request_id
+
+        def before_create
+          self.id = SecureRandom.uuid
+          time = Time.now
+          self.created_at ||= time
+          self.updated_at ||= time
+          super
+        end
+      end
+    end
+  end
+end

data/lib/inferno/repositories/results.rb

@@ -0,0 +1,72 @@
+require_relative 'validate_runnable_reference'
+
+module Inferno
+  module Repositories
+    class Results < Repository
+      include Import[
+                messages_repo: 'repositories.messages',
+                requests_repo: 'repositories.requests',
+                tests_repo: 'repositories.tests',
+                groups_repo: 'repositories.test_groups',
+                suites_repo: 'repositories.test_suites'
+              ]
+
+      def create(params)
+        messages = params.delete(:messages) || []
+        requests = params.delete(:requests) || []
+        super(params).tap do |result|
+          messages.each { |message| messages_repo.create(message.merge(result_id: result.id)) }
+          requests.each { |request| requests_repo.create(request.to_hash.merge(result_id: result.id)) }
+        end
+      end
+
+      def build_entity(params)
+        runnable =
+          if params[:test_id]
+            { test: tests_repo.find(params[:test_id]) }
+          elsif params[:test_group_id]
+            { test_group: groups_repo.find(params[:test_group_id]) }
+          elsif params[:test_suite_id]
+            { test_suite: suites_repo.find(params[:test_suite_id]) }
+          else
+            {}
+          end
+        entity_class.new(params.merge(runnable))
+      end
+
+      def json_serializer_options
+        {
+          include: {
+            messages: {},
+            requests: {
+              include: { headers: {} },
+              only: Entities::Request::SUMMARY_FIELDS
+            }
+          }
+        }
+      end
+
+      class Model < Sequel::Model(db)
+        include ValidateRunnableReference
+
+        one_to_many :messages, class: 'Inferno::Repositories::Messages::Model', key: :result_id
+        one_to_many :requests, class: 'Inferno::Repositories::Requests::Model', key: :result_id
+        many_to_one :test_run, class: 'Inferno::Repositories::TestRuns::Model', key: :test_run_id
+        many_to_one :test_session, class: 'Inferno::Repositories::TestSessions::Model', key: :test_session_id
+
+        def before_create
+          self.id = SecureRandom.uuid
+          time = Time.now
+          self.created_at ||= time
+          self.updated_at ||= time
+          super
+        end
+
+        def validate
+          super
+          errors.add(:result, "'#{result}' is not valid") unless Entities::Result::RESULT_OPTIONS.include?(result)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/repositories/test_groups.rb

@@ -0,0 +1,9 @@
+require_relative 'in_memory_repository'
+
+module Inferno
+  module Repositories
+    # Repository that deals with persistence for the `TestGroup` entity.
+    class TestGroups < InMemoryRepository
+    end
+  end
+end

data/lib/inferno/repositories/test_runs.rb

@@ -0,0 +1,46 @@
+require_relative 'validate_runnable_reference'
+
+module Inferno
+  module Repositories
+    class TestRuns < Repository
+      include Import[results_repo: 'repositories.results']
+
+      def json_serializer_options
+        {
+          include: {
+            results: results_repo.json_serializer_options
+          }
+        }
+      end
+
+      def results_for_test_run(test_run_id)
+        test_run_hash =
+          self.class::Model
+            .find(id: test_run_id)
+            .to_json_data(json_serializer_options)
+            .deep_symbolize_keys!
+
+        test_run_hash[:results]
+          .map! { |result| results_repo.build_entity(result) }
+      end
+
+      class Model < Sequel::Model(db)
+        include ValidateRunnableReference
+
+        one_to_many :results,
+                    eager: [:messages, :requests],
+                    class: 'Inferno::Repositories::Results::Model',
+                    key: :test_run_id
+        many_to_one :test_session, class: 'Inferno::Repositories::TestSessions::Model', key: :test_session_id
+
+        def before_create
+          self.id = SecureRandom.uuid
+          time = Time.now
+          self.created_at ||= time
+          self.updated_at ||= time
+          super
+        end
+      end
+    end
+  end
+end

data/lib/inferno/repositories/test_sessions.rb

@@ -0,0 +1,56 @@
+require_relative 'repository'
+
+module Inferno
+  module Repositories
+    # Repository that deals with persistence for the `TestSession` entity.
+    class TestSessions < Repository
+      include Import[results_repo: 'repositories.results']
+
+      def json_serializer_options
+        {
+          include: {
+            results: results_repo.json_serializer_options,
+            test_runs: {}
+          }
+        }
+      end
+
+      def results_for_test_session(test_session_id)
+        test_session_hash =
+          self.class::Model
+            .find(id: test_session_id)
+            .to_json_data(json_serializer_options)
+            .deep_symbolize_keys!
+
+        test_session_hash[:results]
+          .map! { |result| results_repo.build_entity(result) }
+      end
+
+      class Model < Sequel::Model(db)
+        include Import[test_suites_repo: 'repositories.test_suites']
+
+        one_to_many :results,
+                    eager: [:messages, :requests],
+                    class: 'Inferno::Repositories::Results::Model',
+                    key: :test_session_id
+        one_to_many :test_runs, class: 'Inferno::Repositories::TestRuns::Model', key: :test_session_id
+
+        def before_create
+          self.id = SecureRandom.uuid
+          time = Time.now
+          self.created_at ||= time
+          self.updated_at ||= time
+          super
+        end
+
+        def validate
+          super
+          errors.add(:test_suite_id, 'cannot be empty') if test_suite_id.blank?
+          unless test_suites_repo.exists? test_suite_id # rubocop:disable Style/GuardClause
+            errors.add(:test_suite_id, "'#{test_suite_id}' is not valid")
+          end
+        end
+      end
+    end
+  end
+end