RubyGems - ae_easy-test - Versions diffs - 0.0.0 - Mend

ae_easy-test 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

checksums.yaml +7 -0
data/.gitignore +10 -0
data/.travis.yml +7 -0
data/.yardopts +1 -0
data/CODE_OF_CONDUCT.md +74 -0
data/Gemfile +6 -0
data/Gemfile.lock +65 -0
data/LICENSE +21 -0
data/README.md +16 -0
data/Rakefile +22 -0
data/ae_easy-test.gemspec +49 -0
data/doc/AeEasy.html +117 -0
data/doc/AeEasy/Core.html +117 -0
data/doc/AeEasy/Core/Mock.html +115 -0
data/doc/AeEasy/Core/Mock/FakeExecutor.html +2037 -0
data/doc/AeEasy/Core/Modk.html +105 -0
data/doc/AeEasy/Core/Plugin.html +117 -0
data/doc/AeEasy/Core/Plugin/ExecutorBehavior.html +196 -0
data/doc/AeEasy/Test.html +616 -0
data/doc/AeEasy/Test/Helper.html +1721 -0
data/doc/AeEasy/Test/RecordTask.html +2493 -0
data/doc/_index.html +237 -0
data/doc/class_list.html +51 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +58 -0
data/doc/css/style.css +496 -0
data/doc/file.README.html +91 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +17 -0
data/doc/index.html +91 -0
data/doc/js/app.js +292 -0
data/doc/js/full_list.js +216 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +419 -0
data/doc/top-level-namespace.html +110 -0
data/lib/ae_easy/test.rb +52 -0
data/lib/ae_easy/test/helper.rb +224 -0
data/lib/ae_easy/test/rake.rb +335 -0
data/lib/ae_easy/test/version.rb +6 -0
data/lib/ae_easy_override/core.rb +7 -0
data/lib/ae_easy_override/core/mock.rb +8 -0
data/lib/ae_easy_override/core/mock/fake_executor.rb +324 -0
data/lib/ae_easy_override/core/plugin.rb +8 -0
data/lib/ae_easy_override/core/plugin/executor_behavior.rb +11 -0
metadata +201 -0

data/doc/top-level-namespace.html ADDED

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.9.18
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="AeEasy.html" title="AeEasy (module)">AeEasy</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Fri Mar  8 17:49:24 2019 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.18 (ruby-2.5.3).
+</div>
+    </div>
+  </body>
+</html>

data/lib/ae_easy/test.rb ADDED

@@ -0,0 +1,52 @@
+require 'json'
+require 'ae_easy/core'
+require 'ae_easy_override/core'
+require 'ae_easy/test/helper'
+require 'ae_easy/test/rake'
+require 'ae_easy/test/version'
+module AeEasy
+  module Test
+    # Enable test mode inside executors.
+    def self.enable_test_mode
+      @@test_mode = true
+    end
+    # Disable test mode inside executors.
+    def self.disable_test_mode
+      @@test_mode = false
+    end
+    # Check if test mode is enabled inside executors.
+    #
+    # @return [Boolean] `true` when test mode enabled, else `false`.
+    def self.test_mode?
+      @@test_mode ||= false
+    end
+    # Verbose data log within caller backtrace.
+    #
+    # @param [String] message Message to display.
+    # @param [Object,nil] data (nil) Data to inspect.
+    # @param [Array] log_caller (nil) Log caller. Defaults to method caller.
+    def self.verbose_log message, data = nil, log_caller = nil
+      log_caller ||= caller
+      caller_infos = log_caller.first.split ":"
+      text = data.nil? ? 'nil' : data.inspect
+      puts "\n#{caller_infos[0]}:#{caller_infos[1]} - #{message}#{text}\n\n"
+    end
+    # Verbose a match diff.
+    #
+    # @param [Hash] diff Match diff to verbose.
+    # @param [Array] log_caller (nil) Log caller. Defaults to method caller.
+    def self.verbose_match_diff type, diff, log_caller = nil
+      unless diff[:saved].nil? || diff[:saved].count < 1
+        verbose_log "Non matching saved #{type}: ", diff[:saved], log_caller
+      end
+      unless diff[:expected].nil? || diff[:expected].count < 1
+        verbose_log "Non matching expected #{type}: ", diff[:expected], log_caller
+      end
+    end
+  end
+end

data/lib/ae_easy/test/helper.rb ADDED

@@ -0,0 +1,224 @@
+module AeEasy
+  module Test
+    module Helper
+      # Load and return file contents when exists.
+      #
+      # @param [String] file_path File path to load.
+      # @param [Boolean] should_exists (false) Enforce file existance validation.
+      #
+      # @return [String,nil] File contents.
+      def self.load_file file_path, should_exists = false
+        return nil unless should_exists || File.exists?(file_path)
+        File.open(file_path, 'r', encoding: 'UTF-8').read
+      end
+      # Load and return file contents as json when exists.
+      #
+      # @param [String] file_path File path to load.
+      # @param [Boolean] should_exists (false) Enforce file existance validation.
+      #
+      # @return [Hash,nil] Json file contents.
+      def self.load_json_file file_path, should_exists = false
+        file_content = load_file file_path, should_exists
+        return nil if file_content.nil? || file_content.to_s.strip == ''
+        JSON.parse(file_content)
+      end
+      # Delete keys from a hash.
+      #
+      # @param [Hash] hash Base hash to exclude from.
+      # @param [Array] keys Keys to exclude.
+      #
+      # @return [Hash]
+      def self.delete_keys_from! hash, keys
+        return hash if keys.nil?
+        keys.each{|k|hash.delete k}
+        hash
+      end
+      # Sanitize a copy of the hash provided.
+      #
+      # @param [Hash] raw_hash Hash to sanitize.
+      # @param [Hash] opts ({}) Configuration options.
+      # @option opts [Boolean] :deep_stringify If `true` then stringify all hash
+      #   keys including sublevels.
+      # @option opts [Array,nil] :skip_keys (nil) Key array to delete from
+      #   sanitized hash clone.
+      #
+      # @return [Hash] Sanitized hash clone.
+      def self.sanitize raw_hash, opts
+        opts = {
+          deep_stringify: true,
+          skip_keys: nil
+        }.merge opts
+        hash = (opts[:deep_stringify]) ?
+          AeEasy::Core.deep_stringify_keys(raw_hash) :
+          AeEasy::Core.deep_clone(raw_hash)
+        delete_keys_from! hash, opts[:skip_keys]
+      end
+      # Check if an hash element match the filter.
+      #
+      # @param [Hash] element Element to match.
+      # @param [Hash] filter Filters to apply.
+      # @param [Hash] opts ({}) Configuration options.
+      # @option opts [Boolean] :sanitize (true) Sanitize element and filters
+      #   when `true`.
+      # @option opts [Boolean] :deep_stringify If `true` then stringify all hash
+      #   keys including sublevels before matching.
+      # @option opts [Boolean] :exact_match (true) Filter should match element
+      #   exactly.
+      # @option opts [Array,nil] :skip_keys (nil) Keys to skip on match.
+      #
+      # @return [Boolean] `true` when element match filters, else `false`.
+      def self.match? element, filter, opts = {}
+        opts = {
+          sanitize: true,
+          deep_stringify: true,
+          exact_match: true,
+          skip_keys: nil
+        }.merge opts
+        # Sanitize element and filter when need
+        if opts[:sanitize]
+          element = sanitize element, opts
+          filter = sanitize filter, opts
+        end
+        # Validate exact match when need
+        exact_match = opts[:exact_match]
+        return false if exact_match && element.keys.count != filter.keys.count
+        # Match element filter
+        filter.each do |k,v|
+          return false if exact_match && !element.has_key?(k)
+          return false if element[k] != v
+        end
+        true
+      end
+      # Generate a diff over 2 collections.
+      #
+      # @param [Array] items_a List of items to diff.
+      # @param [Array] items_b List of items to diff.
+      # @param [Hash] opts ({}) Configuration options.
+      # @option opts [Boolean] :exact_match (true) Fragmenent should match
+      #   element exactly.
+      # @option opts [Boolean] :deep_stringify If `true` then stringify all hash
+      #   keys including sublevels before matching.
+      # @option opts [Boolean] :sanitize (true) Sanitize element and filters
+      #   when `true`.
+      # @option opts [Array,nil] :skip_keys (nil) Keys to skip on match.
+      # @option opts [Symbol] :compare_way (:both) Comparison way sense:
+      #   * `:both` Compare left and right.
+      #   * `:right` Compare if `items_a` are inside `items_b`.
+      #   * `:left` Compare if `items_b` are inside `items_a`.
+      #
+      # @return [Hash] Diff results as follows:
+      #   * `[Array] :items_a` Diff items on `items_a` collection.
+      #   * `[Array] :items_b` Diff items on `items_b` collection.
+      #   * `[Boolean] :match` `true` when all items match else `false`.
+      def self.collection_diff items_a, items_b, opts = {}
+        raise NotImplementedError.new('Current status WIP, don\'t use it for now.')
+        opts = {
+          exact_match: true,
+          deep_stringify: true,
+          sanitize: true,
+          skip_keys: nil,
+          compare_way: :both
+        }.merge opts
+        # Match collections items
+        match = nil
+        compare_right = opts[:compare_way] == :right || opts[:compare_way] == :both
+        compare_left = opts[:compare_way] == :left || opts[:compare_way] == :both
+        items_a = items_a.sort{|a,b|b.keys.count <=> a.keys.count}
+        items_b = items_b.sort{|a,b|b.keys.count <=> a.keys.count}
+        remaining_items = items_b + []
+        not_found = []
+        items_a.each do |item_a|
+          found = remaining_items.find do |item_b|
+            match = false
+            match ||= match?(item_a, item_b, opts) if compare_left
+            match ||= match?(item_b, item_a, opts) if compare_right
+            match
+          end
+          # Save diff
+          not_found << item_a if found.nil?
+          remaining_items.delete found
+        end
+        # Send diff results
+        {
+          items_a: not_found,
+          items_b: remaining_items,
+          match: (not_found.count < 1 && remaining_items.count < 1)
+        }
+      end
+      # Validate when an item collection match universe item collection.
+      #
+      # @param [Array] fragment Fragment of universe items to match.
+      # @param [Array] universe List of items.
+      # @param [Hash] opts ({}) Configuration options.
+      # @option opts [Boolean] :exact_match (true) Fragmenent should match
+      #   element exactly.
+      # @option opts [Boolean] :same_count (true) Fragment item count should
+      #   match universe item count exactly.
+      # @option opts [Boolean] :deep_stringify If `true` then stringify all hash
+      #   keys including sublevels before matching.
+      # @option opts [Boolean] :sanitize (true) Sanitize element and filters
+      #   when `true`.
+      # @option opts [Array,nil] :skip_keys (nil) Keys to skip on match.
+      # @option opts [Symbol] :compare_way (:both) Comparison way sense:
+      #   * `:both` Compare left and right.
+      #   * `:right` Compare if `items_a` are inside `items_b`.
+      #   * `:left` Compare if `items_b` are inside `items_a`.
+      #
+      # @return [Boolean]
+      def self.collection_match? fragment, universe, opts = {}
+        opts = {
+          exact_match: true,
+          same_count: true,
+          deep_stringify: true,
+          sanitize: true,
+          skip_keys: nil,
+          compare_way: :both
+        }.merge opts
+        # False when item collections count are different
+        return false if (opts[:match_quantity]) && fragment.count != universe.count
+        diff = collection_diff fragment, universe, opts
+        match = diff[:items_a].count < 1 && diff[:items_b].count < 1
+        match
+      end
+      # Match two collections and calculate diff.
+      #
+      # @param [Array] items_a Item collection to match.
+      # @param [Array] items_b Item collection to match.
+      # @param [Hash] opts ({}) Configuration options.
+      # @option opts [Array] :skip (nil) Keys to skip on match.
+      # @option opts [Symbol] :compare_way (:left) Comparison way sense:
+      #   * `:both` Compare left and right.
+      #   * `:right` Compare if `items_a` are inside `items_b`.
+      #   * `:left` Compare if `items_b` are inside `items_a`.
+      #
+      # @return [Hash] A hash with the following key pairs:
+      #   * `[Hash] :diff` Diff results with `:items_a` and `:items_b` keys.
+      #   * `[Boolean] :match` `true` when match else `false`.
+      def self.match_collections items_a, items_b, opts = {}
+        diff = collection_diff(
+          items_a,
+          items_b,
+          skip_keys: opts[:skip],
+          compare_way: :both
+        )
+        match = (diff[:items_a].count < 1 && diff[:items_b].count < 1)
+        {diff: diff, match: diff[:match]}
+      end
+    end
+  end
+end

data/lib/ae_easy/test/rake.rb ADDED

@@ -0,0 +1,335 @@
+require 'rake'
+module AeEasy
+  module Test
+    # Record rake task generator. It allows AnswersEngine pages snapshots to be
+    #   recorded for an easy way to perform integration tests.
+    class RecordTask
+      # Scraper name to be used to get job_id.
+      #
+      # @return [String,nil]
+      attr_accessor :scraper_name
+      # Will show logs on stdout when enabled (see #enable_verbose and
+      #   #disable_verbose)
+      #
+      # @return [Boolean] `true` when enabled, else `false`.
+      #
+      # @note Default value is `true`.
+      def verbose?
+        @verbose = true if @verbose.nil?
+        @verbose
+      end
+      # Enable verbose.
+      def enable_verbose
+        @verbose = true
+      end
+      # Disable verbose.
+      def disable_verbose
+        @verbose = false
+      end
+      # Job id to be used on page recording.
+      #
+      # @return [Integer,nil]
+      def job_id
+        @job_id ||= nil
+      end
+      # Set job id.
+      #
+      # @param [Integer,nil] value Job id.
+      def job_id= value
+        @job_id = value
+      end
+      # Log text into stdout when verbose is enabled (see #verbose?).
+      #
+      # @param [String] text Message to be log.
+      def log text
+        puts text unless verbose?
+      end
+      # Root directory to record pages. Useful to reduce input map fingerprint.
+      #
+      # @return [String,nil]
+      def root_dir
+        @root ||= nil
+      end
+      # An array of input maps to configure what gid record will be saved into
+      #   each directory. It uses absolute paths when #root_dir is nil, and
+      #   relative paths when it has been assigned.
+      #
+      # @return [Array] Map structure is as follows (see #record_outputs for
+      #   details about `input_map[][:filter][:outputs]` options):
+      #   ```
+      #   [
+      #     {
+      #       gid:'my-gid-123abc',
+      #       dir:'/path/to/input/directory',
+      #       record_content: true/false, # Default: true
+      #       record_failed_content: true/false, # Default: true,
+      #       record_page: true/false, # Default: true
+      #       record_vars: true/false, # Default: false
+      #       filters: {
+      #         outputs: {
+      #           # Output filters
+      #         }
+      #       }
+      #     }, {
+      #       # ...
+      #     }
+      #   ]
+      def input_map
+        @input_map ||= []
+      end
+      # AnswersEngine executor used to get the data to be recorded.
+      #
+      # @return [AnswersEngine::Scraper::Executor]
+      def executor
+        @executor ||= AnswersEngine::Scraper::Executor.new
+      end
+      # Ensures that job_id exists. If #scraper_name is present and no #job_id
+      #   was specified, then it will get the latest `job_id` for the
+      #   `scraper_name` provided.
+      #
+      # @return [Integer,nil] Job id.
+      def ensure_job_id
+        if job_id.nil && !scraper_name.nil?
+          log "Retriving \"job_id\" from scraper \"#{scraper_name}\""
+          job_id = @executor.get_job_id scraper_name.strip
+        end
+        log(job_id.nil? ? 'No "job_id" was specified.' : "Using \"job_id\" #{job_id}.")
+        job_id
+      end
+      # Record a content into a file only when the content is not null. It will
+      #   delete the existing file regardless if a new file will be created or
+      #   not.
+      #
+      # @param [String] path File path to override.
+      # @param [String,nil] content Content to be saved on the file.
+      # @yieldparam [File] file File to save the data into.
+      def record_file path, content, &block
+        if File.exists? path
+          log "Deleting old \"#{path}\" file..."
+          File.delete path
+          log "Done."
+        end
+        if content.nil? && block.nil?
+          log 'Null content detected, skip file.'
+          return
+        end
+        log "Creating \"#{page}\" file..."
+        File.open(path) do |file|
+          file.write content unless content.nil?
+          block.call file unless block.nil?
+        end
+        log "Done."
+      end
+      # Record a page raw content (HTML, XML, excel, zip, etc.) into `content`
+      #   file within the provided directory.
+      #
+      # @param [String] gid Page `gid` to retrieve the data from.
+      # @param [String] dir Directory to save file into.
+      def record_content gid, dir
+        content = executor.get_content gid
+        path = File.join(dir, 'content')
+        record_file path, content
+      end
+      # Record a page raw failed content (HTML, XML, excel, zip, etc.) into
+      #   `failed_content` file within the provided directory.
+      #
+      # @param [String] gid Page `gid` to retrieve the data from.
+      # @param [String] dir Directory to save file into.
+      def record_failed_content gid, dir
+        content = executor.get_failed_content gid
+        path = File.join(dir, 'failed_content')
+        record_file path, content
+      end
+      # Record a page's global or job definition (JSON) into `page.json` file
+      #   within the provided directory.
+      #
+      # @param [String] gid Page `gid` to retrieve the data from.
+      # @param [String] dir Directory to save file into.
+      #
+      # @note It will prefer job page definition over global page unless no
+      #   `job_id` (see #job_id) or `scraper_name` (see #scraper_name) is
+      #   defined.
+      def record_page gid, dir
+        if job_id.nil?
+          log 'Warning: No "scraper_name" or "job_id" was specified, will use global page instead job page.'
+        end
+        @executor.gid = gid
+        @executor.job_id = job_id
+        page = @executor.init_page()
+        content = JSON.pretty_generate page
+        path = File.join(dir, 'page.json')
+        record_file path, content
+      end
+      # Record a page's vars from job page definition (JSON) into `vars.json`
+      #   file within the provided directory.
+      #
+      # @param [String] gid Page `gid` to retrieve the data from.
+      # @param [String] dir Directory to save file into.
+      #
+      # @note It will skip it if no `job_id` (see #job_id) or `scraper_name`
+      #   (see #scraper_name) is defined.
+      def record_vars gid, dir
+        if job_id.nil?
+          log 'Warning: No "scraper_name" or "job_id" was specified, will skip vars.'
+          return
+        end
+        @executor.gid = gid
+        @executor.job_id = job_id
+        page = @executor.init_page()
+        content = JSON.pretty_generate page['vars']
+        path = File.join(dir, 'vars.json')
+        record_file path, content
+      end
+      # Record a collection of outputs (JSON) into `outputs.json` file within
+      #   the provided directory using filters on AnswersEngine executor
+      #   `find_outputs` method to retrieve all matching outputs regardless of
+      #   pagination.
+      #
+      # @param [Hash, nil] filter (nil) Filters to retrieve `outputs`.
+      # @option filter [String] :collection ('default') Output collection.
+      # @option filter [Hash] :query ({}) Query that outputs should match.
+      # @option filter [Hash] :opts ({}) `find_outputs` configuration options
+      #   (see AnswersEngine::Scraper::Executor#find_outputs for details).
+      #
+      # @note Will skip when `nil` is provided as filters.
+      def record_outputs filter = nil
+        if filter.nil?
+          log 'Skip outputs, no filter detected.'
+          return
+        end
+        path = File.join(dir, 'outputs.json')
+        filter = {
+          collection: 'default',
+          query: {},
+          opts: {}
+        }.merge filter
+        record_file path, nil do |file|
+          count = 0
+          page = 1
+          outputs = @executor.find_outputs(
+            filter[:collection],
+            filter[:query],
+            page,
+            100,
+            filter[:opts]
+          )
+          file.write '['
+          while !outputs.nil? && outputs.count > 0
+            page += 1
+            outputs.each do |output|
+              f.write ',' if count > 0
+              count += 1
+              file.write JSON.pretty_generate(output)
+            end
+            outputs = @executor.find_outputs(
+              filter[:collection],
+              filter[:query],
+              page,
+              100,
+              filter[:opts]
+            )
+          end
+          file.write ']'
+        end
+      end
+      # Record a page data into a specific directory.
+      #
+      # @param [Hash] map ({}) Input map configuration.
+      # @option map [String] :gid Page `gid` to retrieve the data from.
+      # @option map [String] :dir Directory to save file into.
+      # @option map [Boolean] :record_content (true) Record content when `true`.
+      # @option map [Boolean] :record_failed_content (true) Record failed_cntent
+      #   when `true`.
+      # @option map [Boolean] :record_page (true) Record page when `true`.
+      # @option map [Boolean] :record_vars (false) Record vars when `true`.
+      # @option map [Hash] :filters ({outputs:nil}) Filter hash for outputs
+      #   recording, will record only when a filter is specify.
+      def record map
+        map = {
+          gid: nil,
+          dir: nil,
+          record_content: true,
+          record_failed_content: true,
+          record_page: true,
+          record_vars: false,
+          filters: {
+            outputs: nil
+          }
+        }.merge map
+        gid = map[:gid].to_s.strip
+        raise ArgumentError.new('"gid" can\'t be empty') if gid == ''
+        dir = map[:dir].to_s.strip
+        raise ArgumentError.new('"dir" can\'t be empty') if dir == ''
+        dir = File.join root_dir, dir unless root_dir.nil? || root_dir.strip == ''
+        dir = File.expand_path dir
+        unless Dir.exist? dir
+          raise ArgumentError.new "\"#{dir}\" don't exists or is not a directory."
+        end
+        log "Recording on \"#{dir}\" directory..."
+        record_content gid, dir if map[:content]
+        record_failed_content gid, dir if map[:failed_content]
+        record_page gid, dir if map[:page]
+        record_vars gid, dir if map[:vars]
+        filters = map[:filters]
+        unless filters.nil?
+          record_outputs filters[:outputs] unless filters[:outputs].nil?
+        end
+        log "Finish recording \"#{dir}\" directory."
+      end
+      # Record pages from an input map collection.
+      #
+      # @param [Array] input_map Input map collection (see #input_map for
+      #   structure).
+      def record_pages input_map
+        ensure_job_id
+        input_map.each do |map|
+          record_page gid, dir, opts
+        end
+      end
+      # Create the record rake task
+      def create_task
+        namespace 'ae_easy' do
+          desc "Generates input files by gid into the configured directories, use these on context loading."
+          task :record_pages do
+            record_pages input_map
+          end
+        end
+      end
+      # Initialize record task. Use block to configure record task.
+      #
+      # @yieldparam [AeEasy::Test::RecordTask] task Self.
+      def initialize &block
+        verbose = nil
+        block.call self unless block.nil?
+        create_task
+      end
+    end
+  end
+end