moto 0.9.11 → 0.9.17

data/lib/initializer.rb

@@ -1,7 +0,0 @@
-module Moto
-  class Initializer
-    def initialize(runner)
-      @runner = runner
-    end
-  end
-end

data/lib/parser.rb

@@ -1,182 +0,0 @@
-require 'optparse'
-require 'yaml'
-
-require_relative '../lib/cli'
-require_relative '../lib/app_generator'
-require_relative '../lib/config'
-module Moto
-
-  class Parser
-
-    def self.run(argv)
-      begin
-
-        if argv[0] == '--version'
-          puts Moto::VERSION
-        elsif argv[0] == 'run' && argv.length > 1
-          Moto::Cli.run(run_parse(argv))
-        elsif argv[0] == 'generate' && argv.length > 1
-          Moto::AppGenerator.run(generate_parse(argv))
-        else
-          show_help
-        end
-      rescue SystemExit => e
-        Kernel.exit(e.status)
-      rescue Exception => e
-        puts e.message + "\n\n"
-        puts e.backtrace.join("\n")
-      end
-    end
-
-    def self.run_parse(argv)
-      require 'bundler/setup'
-      Bundler.require
-
-      # Default options
-      options = {}
-      options[:listeners]   = []
-      options[:run_name]    = nil
-      options[:suite_name]  = nil
-      options[:assignee]    = nil
-      options[:stop_on]     = {error: false, fail: false, skip: false}
-
-      # Parse arguments
-      OptionParser.new do |opts|
-        opts.on('-t', '--tests Tests', Array)              { |v| options[:tests]        = v }
-        opts.on('-g', '--tags Tags', Array)                { |v| options[:tags]         = v }
-        opts.on('-f', '--filters Filters', Array)          { |v| options[:filters]      = v }
-        opts.on('-l', '--listeners Listeners', Array)      { |v| options[:listeners]    = v }
-        opts.on('-e', '--environment Environment')         { |v| options[:environment]  = v }
-        opts.on('-r', '--runname RunName')                 { |v| options[:run_name]     = v }
-        opts.on('-s', '--suitename SuiteName')             { |v| options[:suite_name]   = v }
-        opts.on('-a', '--assignee Assignee')               { |v| options[:assignee]     = v }
-        opts.on('-c', '--config Config')                   { |v| options[:config_name]  = v }
-        opts.on('--threads ThreadCount', Integer)          { |v| options[:threads]      = v }
-        opts.on('--attempts AttemptCount', Integer)        { |v| options[:attempts]     = v }
-        opts.on('--stop-on-error')                         { options[:stop_on][:error] = true }
-        opts.on('--stop-on-fail')                          { options[:stop_on][:fail]  = true }
-        opts.on('--stop-on-skip')                          { options[:stop_on][:skip]  = true }
-        opts.on('--dry-run')                               { options[:dry_run]         = true }
-      end.parse!
-
-      if options[:tests]
-        options[:tests].each do |path|
-          path.sub!(%r{\/$}, '') # remove trailing "/"
-        end
-      end
-
-      if options[:run_name].nil?
-        options[:run_name] = evaluate_name(options[:tests], options[:tags], options[:filters])
-      end
-
-      if options[:environment]
-        Moto::Lib::Config.environment = options[:environment]
-        Moto::Lib::Config.load_configuration(options[:config_name] ? options[:config_name] : 'moto')
-      else
-        puts 'ERROR: Environment is mandatory.'
-        Kernel.exit(-1)
-      end
-
-      Moto::Lib::Config.moto[:test_runner][:thread_count] = options[:threads] if options[:threads]
-      Moto::Lib::Config.moto[:test_runner][:test_attempt_max] = options[:attempts] if options[:attempts]
-      Moto::Lib::Config.moto[:test_runner][:dry_run] = options[:dry_run] if options[:dry_run]
-
-      return options
-    end
-
-    # Generate default name based on input parameters
-    def self.evaluate_name(tests, tags, filters)
-      name = ''
-
-      if tests
-        name << "Tests: #{tests.join(',')}  "
-      end
-
-      if tags
-        name << "Tags: #{tags.join(',')}  "
-      end
-
-      if filters
-        name << "Filters: #{filters.join(',')}  "
-      end
-
-      return name
-    end
-
-    # Parses attributes passed to the application when run by 'moto generate'
-    def self.generate_parse(argv)
-      options = {}
-
-      OptionParser.new do |opts|
-        opts.on('-t', '--test Test') { |v| options[:dir ] = v }
-        opts.on('-a', '--appname AppName') { |v| options[:app_name ] = v }
-        opts.on('-b', '--baseclass BaseClass') { |v| options[:base_class] = v }
-        opts.on('-f', '--force') { options[:force ] = true }
-      end.parse!
-
-      options[:dir] = options[:dir].underscore
-
-      if options[:app_name].nil?
-        options[:app_name] = 'MotoApp'
-      end
-
-      return options
-    end
-
-    def self.show_help
-      puts """
-      Moto (#{Moto::VERSION}) CLI Help:
-      moto --version Display current version
-
-      MOTO RUN:
-       -t, --tests       Tests to be executed.
-       -g, --tags        Tags of tests to be executed.
-                         Use # MOTO_TAGS: TAGNAME in test to assign tag.
-       -f, --filters     Tags that filter tests passed via -t parameter.
-                         Only tests in appropriate directory, having all of the specified tags will be executed.
-                         Use # MOTO_TAGS: TAGNAME1 in test to assign tag.
-                         Use ~ to filter tests that do not contain specific tag, e.g. ~tag
-
-
-       -e, --environment Mandatory environment. Environment constants and tests parametrized in certain way depend on this.
-       -c, --config      Name of the config, without extension, to be loaded from MotoApp/config/CONFIG_NAME.rb
-                         Default: moto (which loads: MotoApp/config/moto.rb)
-
-
-       -l, --listeners   Reporters to be used.
-                         Defaults are Moto::Reporting::Listeners::ConsoleDots, Moto::Reporting::Listeners::JunitXml
-                         One reporter that is always used: Moto::Reporting::Listeners::KernelCode
-       -s, --suitename   Name of the test suite to which should aggregate the results of current test run.
-                         Required when specifying MotoWebUI as one of the listeners.
-       -r, --runname     Name of the test run to which everything will be reported when using MotoWebUI.
-                         Default: Value of -g or -t depending on which one was specified.
-       -a, --assignee    ID of a person responsible for current test run.
-                         Can have a default value set in config/webui section.
-       --threads         Thread count. Run tests in parallel.
-       --attempts        Attempt count. Max number of test execution times if failed.
-
-       --stop-on-error   Moto will stop test execution when an error is encountered in test results
-       --stop-on-fail    Moto will stop test execution when a failure is encountered in test results
-       --stop-on-skip    Moto will stop test execution when a skip is encountered in test results
-       --dry-run         Moto will list all test cases which would be run with provided arguments
-
-
-      MOTO GENERATE:
-       -t, --test        Path and name of the test to be created.
-                         Examples:
-                         -ttest_name          will create MotoApp/tests/test_name/test_name.rb
-                         -tdir/test_name      will create MotoApp/tests/dir/test_name/test_name.rb
-       -a, --appname     Name of the application. Will be also used as topmost module in test file.
-                         Default: MotoApp
-       -b, --baseclass   File, without extension, with base class from which test will derive. Assumes one class per file.
-                         Examples:
-                         -btest_base          will use the file in MotoApp/lib/test/test_base.rb
-                         -bsubdir/test_base   will use the file in MotoApp/lib/test/subdir/test_base.rb
-                         By default class will derive from Moto::Test
-       -f, --force       Forces generator to overwrite previously existing class file in specified location.
-                         You have been warned.
-      """
-    end
-
-  end
-end

data/lib/reporting/listeners/webui_deprecated.rb

@@ -1,127 +0,0 @@
-require 'rest-client'
-require 'sys/uname'
-
-module Moto
-  module Reporting
-    module Listeners
-      class WebuiDeprecated < Base
-
-        REST_MAX_TRIES = 3
-        REST_TIMEOUT = 15
-
-        def start_run
-
-          @url = config[:url]
-          @send_log_on_pass = config[:send_log_on_pass]
-
-          data = {
-              name: run_params[:name],
-              result: :running,
-              cnt_all: nil,
-              cnt_passed: nil,
-              cnt_failure: nil,
-              cnt_error: nil,
-              cnt_skipped: nil,
-              user: Sys::Uname.sysname.downcase.include?('windows') ? ENV['USERNAME'] : ENV['LOGNAME'],
-              host: Sys::Uname.nodename,
-              pid: Process.pid
-          }
-
-          result = try {
-            RestClient::Request.execute(method: :post, url: "#{@url}/api/runs", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
-          }
-
-          @run = JSON.parse(result)
-          @tests = {}
-        end
-
-        def end_run(run_status)
-          # PUT http://sandbox.dev:3000/api/runs/1
-          data = {
-              result: run_status.result,
-              cnt_all: run_status.tests_all.length,
-              cnt_passed: run_status.tests_passed.length,
-              cnt_failure: run_status.tests_failed.length,
-              cnt_error: run_status.tests_error.length,
-              cnt_skipped: run_status.tests_skipped.length,
-              duration: run_status.duration
-          }
-
-          result = try {
-              RestClient::Request.execute(method: :put, url: "#{@url}/api/runs/#{@run['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
-          }
-          @run = JSON.parse(result)
-        end
-
-        def start_test(test_status, test_metadata)
-          # POST http://sandbox.dev:3000/api/tests/create
-          data = {
-              name: test_status.name,
-              class_name: test_status.test_class_name,
-              log: nil,
-              run_id: @run['id'],
-              env: test_status.env,
-              parameters: test_status.params.to_s,
-              result: :running,
-              error: nil,
-              failures: nil
-          }
-
-          result = try {
-            RestClient::Request.execute(method: :post, url: "#{@url}/api/tests", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
-          }
-          @tests[test_status.name] = JSON.parse(result)
-        end
-
-        def end_test(test_status)
-
-          # don't send the log if the test has passed and appropriate flag is set to false
-          if test_status.results.last.code == Moto::Test::Result::PASSED && !@send_log_on_pass
-            full_log = nil
-          else
-            full_log = File.read(test_status.log_path)
-          end
-
-          data = {
-              log: full_log,
-              result: test_status.results.last.code,
-              error: test_status.results.last.code == Moto::Test::Result::ERROR ? nil : test_status.results.last.message,
-              failures: test_failures(test_status),
-              duration: test_status.duration
-          }
-
-          result = try {
-            RestClient::Request.execute(method: :put, url: "#{@url}/api/tests/#{@tests[test_status.name]['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
-          }
-          @tests[test_status.name] = JSON.parse(result)
-        end
-
-        # @return [String] string with messages of all failures in a test
-        def test_failures(test_status)
-          test_status.results.last.failures.join("\n\t")
-        end
-
-        # Tries to execute, without an error, block of code passed to the function.
-        # @param block Block of code to be executed up to MAX_REST_TRIES
-        def try(&block)
-
-          tries = REST_MAX_TRIES
-
-          begin
-            yield
-          rescue
-            tries -= 1
-            tries > 0 ? retry : raise
-          end
-        end
-
-        # @return [Hash] Hash with config for WebUI
-        def config
-          Moto::Lib::Config.moto[:test_reporter][:listeners][:webui]
-        end
-        private :config
-
-      end
-    end
-  end
-end

data/lib/runner/dry_runner.rb

@@ -1,37 +0,0 @@
-require_relative '../reporting/test_reporter'
-
-module Moto
-  module Runner
-    class DryRunner
-
-      # @param [Array] tests_metadata Collection of [Moto::Test::Metadata] objects describing Tests
-      # @param [Moto::Reporting::TestReporter] test_reporter Reporter of test/run statuses that communicates with external status listeners
-      def initialize(tests_metadata, test_reporter)
-        @tests_metadata = tests_metadata
-        @test_reporter = test_reporter
-      end
-
-      def run
-        @test_reporter.report_start_run
-
-        test_generator = TestGenerator.new
-        @tests_metadata.each do |metadata|
-          test_variants = test_generator.get_test_with_variants(metadata)
-          test_variants.each do |tc|
-            @test_reporter.report_start_test(tc.status, tc.metadata)
-            tc.status.initialize_run
-            tc.status.log_exception(Exceptions::TestSkipped.new('Dry run.'))
-            tc.status.finalize_run
-            @test_reporter.report_end_test(tc.status)
-          end
-        end
-
-        @test_reporter.report_end_run
-
-        # Exit application with code that represents status of test run
-        Kernel.exit(@test_reporter.run_status.bitmap)
-      end
-
-    end
-  end
-end

data/lib/runner/test_provider.rb

@@ -1,68 +0,0 @@
-require 'thread'
-require_relative 'test_generator'
-
-module Moto
-  module Runner
-    # Thread safe provider of test instances
-    class TestProvider
-
-      # @param [Array] tests_metadata
-      def initialize(tests_metadata)
-        super()
-        @test_repeats = Moto::Lib::Config.moto[:test_runner][:test_repeats]
-        @current_test_repeat = 1
-        @queue = Queue.new
-        @tests_metadata = tests_metadata
-        @test_generator = TestGenerator.new
-      end
-
-      # Use this to retrieve tests safely in multithreaded environment
-      def get_test
-        create_tests
-        @queue.pop
-      end
-
-      # Pushes new tests to the queue if possible and the queue is already empty
-      def create_tests
-        if @queue.empty?
-
-          test_metadata = get_test_metadata
-
-          if test_metadata
-            test_variants = @test_generator.get_test_with_variants(test_metadata)
-            test_variants.each do |test|
-              @queue.push(test)
-            end
-          end
-
-        end
-      end
-      private :create_tests
-
-      # Returns metadata of the test while supporting the number of repeats specified by the user
-      # return [Moto::Test::Metadata]
-      def get_test_metadata
-
-        if @current_test_repeat == 1
-          @test_metadata = @tests_metadata.shift
-        end
-
-        if @current_test_repeat == @test_repeats
-          @current_test_repeat = 1
-        else
-          @current_test_repeat += 1
-        end
-
-        @test_metadata
-      end
-      private :get_test_metadata
-
-      # Number of threads waiting for a job
-      def num_waiting
-        @queue.num_waiting
-      end
-
-    end
-  end
-end
-

data/lib/runner/test_runner.rb

@@ -1,71 +0,0 @@
-require_relative '../reporting/test_reporter'
-require_relative './test_provider'
-
-module Moto
-  module Runner
-    class TestRunner
-
-      attr_reader :test_reporter
-
-      # @param [Array] tests_metadata Collection of [Moto::Test::Metadata] objects describing Tests
-      # @param [Moto::Reporting::TestReporter] test_reporter Reporter of test/run statuses that communicates with external status listeners
-      # @param [Hash] stop_conditions Describe when TestRunner should abnormally stop its execution
-      #   :error  [Boolean]
-      #   :fail   [Boolean]
-      #   :skip   [Boolean]
-      def initialize(tests_metadata, test_reporter, stop_conditions)
-        @tests_metadata = tests_metadata
-        @test_reporter = test_reporter
-        @stop_conditions = stop_conditions
-      end
-
-      def run
-        test_provider = TestProvider.new(@tests_metadata)
-        threads_max = Moto::Lib::Config.moto[:test_runner][:thread_count] || 1
-
-        # remove log/screenshot files from previous execution
-        @tests_metadata.each do |metadata|
-          FileUtils.rm_rf("#{File.dirname(metadata.test_path)}/logs")
-        end
-
-        @test_reporter.report_start_run
-
-        # Create as many threads as we're allowed by the config file.
-        # test_provider.get_test - will invoke Queue.pop thus putting the thread to sleep
-        # once there is no more work.
-
-        Thread.abort_on_exception = true
-
-        (1..threads_max).each do |index|
-          Thread.new do
-            Thread.current[:id] = index
-            loop do
-              tc = ThreadContext.new(test_provider.get_test, @test_reporter)
-              tc.run
-            end
-          end
-        end
-
-        # Waiting for all threads to run out of work so we can end the application
-        # or abonormal termination to be triggered based on options provided by the user
-        loop do
-          run_status = @test_reporter.run_status
-          if (test_provider.num_waiting == threads_max) ||
-             (@stop_conditions[:error] && run_status.tests_error.length   > 0) ||
-             (@stop_conditions[:fail]  && run_status.tests_failed.length  > 0) ||
-             (@stop_conditions[:skip]  && run_status.tests_skipped.length > 0)
-            break
-          end
-
-          sleep 2
-        end
-
-        @test_reporter.report_end_run
-
-        # Exit application with code that represents status of test run
-        Kernel.exit(@test_reporter.run_status.bitmap)
-      end
-
-    end
-  end
-end