ae_easy-core 0.0.3

data/lib/ae_easy/core/mock.rb

@@ -0,0 +1,44 @@
+require 'ae_easy/core/mock/fake_db'
+require 'ae_easy/core/mock/fake_executor'
+require 'ae_easy/core/mock/fake_parser'
+require 'ae_easy/core/mock/fake_seeder'
+
+module AeEasy
+  module Core
+    module Mock
+      # Generate a context and message queue from a list of exposed methods.
+      #
+      # @param [Array] exposed_methods List of exposed methods.
+      #
+      # @example
+      #   exposed_methods = [:boo, :bar]
+      #   context, message_queue = AeEasy::Core::Mock.context_vars exposed_methods
+      #   context.boo 1, 2
+      #   context.bar 'A', 'B'
+      #   context.bar '111', '222'
+      #   message_queue
+      #   # => [
+      #   #   [:boo, [1, 2]],
+      #   #   [:bar, ['A', 'B']],
+      #   #   [:bar, ['111', '222']]
+      #   # ]
+      #
+      # @return [Array] `[context, message_queue]` being:
+      #   * `context`: Object implementing exposed methods.
+      #   * `[Array] message_queue`: Array to store messages.
+      def self.context_vars exposed_methods
+        context = Object.new
+        metaclass = class << context; self; end
+        message_queue = [] # Beat reference bug
+        exposed_methods = exposed_methods
+        exposed_methods.each do |key|
+          metaclass.send(:define_method, key) do |*args|
+            # Record all method calls into message queue for easy access
+            message_queue << [key, args]
+          end
+        end
+        [context, message_queue]
+      end
+    end
+  end
+end

data/lib/ae_easy/core/mock/fake_db.rb

@@ -0,0 +1,280 @@
+module AeEasy
+  module Core
+    module Mock
+      # Fake in memory database that emulates `Answersengine` database objects' black box behavior.
+      class FakeDb
+        # Page id keys, analog to primary keys.
+        PAGE_KEYS = ['gid'].freeze
+        # Output id keys, analog to primary keys.
+        OUTPUT_KEYS = ['_id', '_collection'].freeze
+        # Default collection for saved outputs
+        DEFAULT_COLLECTION = 'default'
+
+        # Generate a smart collection with keys and initial values.
+        #
+        # @param [Array] keys Analog to primary keys, combination will be uniq.
+        # @param [Hash] opts Configuration options (see AeEasy::Core::SmartCollection#initialize).
+        #
+        # @return [AeEasy::Core::SmartCollection]
+        def self.new_collection keys, opts = {}
+          AeEasy::Core::SmartCollection.new keys, opts
+        end
+
+        # Generate a fake UUID.
+        #
+        # @param seed (nil) Object to use as seed for uuid.
+        #
+        # @return [String]
+        def self.fake_uuid seed = nil
+          seed ||= (Time.new.to_f + rand)
+          Digest::SHA1.hexdigest seed.to_s
+        end
+
+        # Build a page with defaults by using FakeDb engine.
+        #
+        # @param [Hash] page Page initial values.
+        # @param [Hash] opts ({}) Configuration options (see #initialize).
+        #
+        # @return [Hash]
+        def self.build_page page, opts = {}
+          temp_db = AeEasy::Core::Mock::FakeDb.new opts
+          temp_db.enable_page_gid_override
+          temp_db.pages << page
+          temp_db.pages.first
+        end
+
+        # Build a fake page by using FakeDb engine.
+        #
+        # @param [Hash] opts ({}) Configuration options (see #initialize).
+        # @option opts [String] :url ('https://example.com') Page url.
+        #
+        # @return [Hash]
+        def self.build_fake_page opts = {}
+          page = {
+            'url' => (opts[:url] || 'https://example.com')
+          }
+          build_page page, opts
+        end
+
+        # Fake job id.
+        # @return [Integer,nil]
+        def job_id
+          @job_id ||= rand(1000) + 1
+        end
+
+        # Set fake job id value.
+        def job_id= value
+          @job_id = value
+        end
+
+        # Current fake page gid.
+        # @return [Integer,nil]
+        def page_gid
+          @page_gid ||= self.class.fake_uuid
+        end
+
+        # Set current fake page gid value.
+        def page_gid= value
+          @page_gid = value
+        end
+
+        # Enable page gid override on page insert.
+        def enable_page_gid_override
+          @allow_page_gid_override = true
+        end
+
+        # Disable page gid override on page insert.
+        def disable_page_gid_override
+          @allow_page_gid_override = false
+        end
+
+        # Specify whenever page gid overriding by user is allowed on page
+        #   insert.
+        #
+        # @return [Boolean] `true` when allowed, else `false`.
+        def allow_page_gid_override?
+          @allow_page_gid_override ||= false
+        end
+
+        # Initialize fake database.
+        #
+        # @param [Hash] opts ({}) Configuration options.
+        # @option opts [Integer,nil] :job_id Job id default value.
+        # @option opts [String,nil] :page_gid Page gid default value.
+        # @option opts [Boolean, nil] :allow_page_gid_override (false) Specify
+        #   whenever page gid can be overrided on page insert.
+        def initialize opts = {}
+          self.job_id = opts[:job_id]
+          self.page_gid = opts[:page_gid]
+          @allow_page_gid_override = opts[:allow_page_gid_override].nil? ? false : !!opts[:allow_page_gid_override]
+        end
+
+        # Generate a fake UUID based on page data:
+        #   * url
+        #   * method
+        #   * headers
+        #   * fetch_type
+        #   * cookie
+        #   * no_redirect
+        #   * body
+        #   * ua_type
+        #
+        # @param [Hash] data Output data.
+        #
+        # @return [String]
+        def generate_page_gid data
+          fields = [
+            'url',
+            'method',
+            'headers',
+            'fetch_type',
+            'cookie',
+            'no_redirect',
+            'body',
+            'ua_type'
+          ]
+          seed = data.select{|k,v|fields.include? k}.hash
+          self.class.fake_uuid seed
+        end
+
+        # Get page keys with key generators to emulate saving on db.
+        # @private
+        #
+        # @return [Hash]
+        def page_defaults
+          @page_keys ||= {
+            'url' => nil,
+            'method' => 'GET',
+            'headers' => {},
+            'fetch_type' => 'standard',
+            'cookie' => nil,
+            'no_redirect' => false,
+            'body' => nil,
+            'ua_type' => 'desktop',
+            'vars' => {}
+          }
+        end
+
+        # Stored page collection.
+        #
+        # @return [AeEasy::Core::SmartCollection]
+        #
+        # @note Page gid will be replaced on insert by an auto generated uuid
+        #   unless page gid overriding is enabled
+        #   (see #allow_page_gid_override?)
+        def pages
+          return @pages unless @page.nil?
+
+          collection = self.class.new_collection PAGE_KEYS,
+            defaults: page_defaults
+          collection.bind_event(:before_defaults) do |collection, raw_item|
+            AeEasy::Core.deep_stringify_keys raw_item
+          end
+          collection.bind_event(:before_insert) do |collection, item, match|
+            if item['gid'].nil? || !allow_page_gid_override?
+              item['gid'] = generate_page_gid item
+            end
+            item
+          end
+          @pages ||= collection
+        end
+
+        # Generate a fake UUID based on output fields without `_` prefix.
+        #
+        # @param [Hash] data Output data.
+        #
+        # @return [String]
+        def generate_output_id data
+          seed = data.select{|k,v|k.to_s =~ /^[^_]/}.hash
+          self.class.fake_uuid seed
+        end
+
+        # Get output keys with key generators to emulate saving on db.
+        # @private
+        #
+        # @return [Hash]
+        def output_defaults
+          @output_keys ||= {
+            '_collection' => DEFAULT_COLLECTION,
+            '_job_id' => lambda{|output| job_id},
+            '_created_at' => lambda{|output| Time.new.strftime('%Y-%m-%dT%H:%M:%SZ')},
+            '_gid' => lambda{|output| page_gid}
+          }
+        end
+
+        # Stored output collection
+        #
+        # @return [AeEasy::Core::SmartCollection]
+        def outputs
+          return @outputs unless @outputs.nil?
+          collection = self.class.new_collection OUTPUT_KEYS,
+            defaults: output_defaults
+          collection.bind_event(:before_defaults) do |collection, raw_item|
+            AeEasy::Core.deep_stringify_keys raw_item
+          end
+          collection.bind_event(:before_insert) do |collection, item, match|
+            item['_id'] ||= generate_output_id item
+            item
+          end
+          @outputs ||= collection
+        end
+
+        # Match data to filters.
+        # @private
+        #
+        # @param data Hash containing data.
+        # @param filters Filters to apply on match.
+        #
+        # @return [Boolean]
+        #
+        # @note Missing and `nil` values on `data` will match when `filters`'
+        #   field is `nil`.
+        def match? data, filters
+          filters.each do |key, value|
+            return false if data[key] != value
+          end
+          true
+        end
+
+        # Search items from a collection.
+        #
+        # @param [Symbol] collection Allowed values: `:outputs`, `:pages`.
+        # @param [Hash] filter Filters to query.
+        # @param [Integer] offset (0) Search results offset.
+        # @param [Integer|nil] limit (nil) Limit search results count. Set to `nil` for unlimited.
+        #
+        # @raise ArgumentError On unknown collection.
+        #
+        # @note _Warning:_ It uses table scan to filter and should be used on test suites only.
+        def query collection, filter, offset = 0, limit = nil
+          return [] unless limit.nil? || limit > 0
+
+          # Get collection items
+          items = case collection
+          when :outputs
+            outputs
+          when :pages
+            pages
+          else
+            raise ArgumentError.new "Unknown collection #{collection}."
+          end
+
+          # Search items
+          count = 0
+          matches = []
+          items.each do |item|
+            next unless match? item, filter
+            count += 1
+
+            # Skip until offset
+            next unless offset < count
+            # Break on limit reach
+            break unless limit.nil? || matches.count < limit
+            matches << item
+          end
+          matches
+        end
+      end
+    end
+  end
+end

data/lib/ae_easy/core/mock/fake_executor.rb

@@ -0,0 +1,207 @@
+module AeEasy
+  module Core
+    module Mock
+      # Fake executor that emulates `AnswersEngine` executor.
+      module FakeExecutor
+        # Page content.
+        # @return [String,nil]
+        attr_accessor :content
+        # Failed page content.
+        # @return [String,nil]
+        attr_accessor :failed_content
+
+        include AnswersEngine::Plugin::ContextExposer
+
+        # Validate executor methods compatibility.
+        # @private
+        #
+        # @param [Array] source Answersengine executor method collection.
+        # @param [Array] fragment Fake executor method collection.
+        #
+        # @return [Hash]
+        # @raise [AeEasy::Core::Exception::OutdatedError] When missing methods.
+        def self.check_compatibility source, fragment
+          report = AeEasy::Core.analyze_compatibility source, fragment
+
+          unless report[:new].count < 1
+            # Warn when outdated
+            warn <<-LONGDESC.gsub(/^\s+/,'')
+              It seems answersengine has new unmapped methods, try updating
+              ae_easy-core gem or contacting gem maintainer to update it.
+              New methods: #{report[:new].join ', '}
+            LONGDESC
+          end
+
+          # Ensure no missing methods
+          unless report[:is_compatible]
+            message = <<-LONGDESC.gsub(/^\s+/,'')
+              There are missing methods! Check your answersengine gem version.
+              Missing methods: #{report[:missing].join ', '}
+            LONGDESC
+            raise AeEasy::Core::Exception::OutdatedError.new(message)
+          end
+
+          report
+        end
+
+        # Draft pages, usually get saved after execution.
+        # @return [Array]
+        def pages
+          @pages ||= []
+        end
+
+        # Draft outputs, usually get saved after execution.
+        # @return [Array]
+        def outputs
+          @outputs ||= []
+        end
+
+        # Remove all elements on pages.
+        # @private
+        def clear_draft_pages
+          @pages.clear
+        end
+
+        # Remove all elements on outputs.
+        # @private
+        def clear_draft_outputs
+          @outputs.clear
+        end
+
+        # Fake database to represent what it is saved.
+        def db
+          @db ||= AeEasy::Core::Mock::FakeDb.new
+        end
+
+        # Initialize object.
+        #
+        # @param [Hash] opts ({}) Configuration options.
+        # @option opts [Array] :pages (nil) Array to initialize pages, can be nil for empty.
+        # @option opts [Array] :outputs (nil) Array to initialize outputs, can be nil for empty.
+        # @option opts [Integer] :job_id (nil) A number to represent the job_id.
+        # @option opts [Hash] :page (nil) Current page.
+        #
+        # @raise [ArgumentError] When pages or outputs are not Array.
+        def initialize opts = {}
+          unless opts[:pages].nil? || opts[:pages].is_a?(Array)
+            raise ArgumentError.new "Pages must be an array."
+          end
+          @pages = opts[:pages]
+          unless opts[:outputs].nil? || opts[:outputs].is_a?(Array)
+            raise ArgumentError.new "Outputs must be an array."
+          end
+          @outputs = opts[:outputs]
+          self.job_id = opts[:job_id]
+          self.page = opts[:page]
+        end
+
+        # Fake job ID used by executor.
+        # @return [Integer,nil]
+        def job_id
+          db.job_id
+        end
+
+        # Set fake job id value.
+        def job_id= value
+          db.job_id = value
+          page['job_id'] = value
+        end
+
+        # Current page used by executor.
+        # @return [Hash,nil]
+        def page
+          @page ||= AeEasy::Core::Mock::FakeDb.build_fake_page job_id: job_id
+        end
+
+        # Set current page.
+        def page= value
+          unless value.nil?
+            value = AeEasy::Core::Mock::FakeDb.build_page value
+            self.job_id = value['job_id'] unless value['job_id'].nil?
+            value['job_id'] ||= job_id
+            db.page_gid = value['gid'] unless value['gid'].nil?
+          end
+          @page = value
+        end
+
+        # Retrive a list of saved pages. Drafted pages can be included.
+        def saved_pages
+          db.pages
+        end
+
+        # Retrive a list of saved outputs.
+        def saved_outputs
+          db.outputs
+        end
+
+        # Save a page collection on db.
+        #
+        # @param [Array] list Collection of pages to save.
+        def save_pages list
+          list.each{|page| db.pages << page}
+        end
+
+        # Save an output collection on db.
+        #
+        # @param [Array] list Collection of outputs to save.
+        def save_outputs list
+          list.each{|output| db.outputs << output}
+        end
+
+        # Save draft pages into db and clear draft queue.
+        def flush_pages
+          save_pages pages
+          clear_draft_pages
+        end
+
+        # Save draft outputs into db and clear draft queue.
+        def flush_outputs
+          save_outputs outputs
+          clear_draft_outputs
+        end
+
+        # Save all drafts into db and clear draft queues.
+        def flush
+          flush_pages
+          flush_outputs
+        end
+
+        # Find outputs by collection and query with pagination.
+        #
+        # @param [String] collection ('default') Collection name.
+        # @param [Hash] query ({}) Filters to query.
+        # @param [Integer] page (1) Page number.
+        # @param [Integer] per_page (30) Page size.
+        #
+        # @return [Array]
+        def find_outputs collection = 'default', query = {}, page = 1, per_page = 30
+          count = 0
+          offset = (page - 1) * per_page
+          fixed_query = query.merge(
+            '_collection' => collection
+          )
+          db.query :outputs, fixed_query, offset, per_page
+        end
+
+        # Find one output by collection and query with pagination.
+        #
+        # @param [String] collection ('default') Collection name.
+        # @param [Hash] query ({}) Filters to query.
+        #
+        # @return [Hash, nil]
+        def find_output collection = 'default', query = {}
+          result = find_outputs(collection, query, 1, 1)
+          result.nil? ? nil : result.first
+        end
+
+        # Execute an script file as an executor.
+        #
+        # @param [String] file_path Script file path to execute.
+        def execute_script file_path, vars = {}
+          eval(File.read(file_path), isolated_binding(vars), file_path)
+          flush
+        end
+      end
+    end
+  end
+end