moto 0.0.33 → 0.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b186db0c69b5623b309a299d29cf4d8b0de8764d
-  data.tar.gz: d5aa6f1066e88d132c36bfb0267b288241ae67e2
+  metadata.gz: 8b5492188f2eeb8cc2270194377f7da621456203
+  data.tar.gz: 95f4afebe273fdcf4a6a5482457f0193aee3dc6c
 SHA512:
-  metadata.gz: 24c72f61c55a48defac80689b89313401965f75700868eb7ca2c3b6981d9ae6276729ed99e445a35297c6435cf45aec93413c200b69686f078fcca34e6d5cb88
-  data.tar.gz: 1fb46b41e2ef571ebc51baa7e987cc4252e91cec81daa6ff28d6e5b82ae9c6d1cd92f381de462940d660ec0c72a3833b9350426f12671679ddd2f1b14e124685
+  metadata.gz: 8f0d02d6cffea6babcb5126ae4e0c538a8600fce9617e6566a2709dbd582e3de82b54eeb47f414166aa19fce854022966a2b36c703071df84861b061e9052bcb
+  data.tar.gz: 4d636279703d273404c25ca98c6c83a74676da594daf0d33ee6fc87854a743743cc5cc5a935b3fe8519dec776046527ffcb114f1d0acb44ae4192694dbc282d5

data/lib/cli.rb

@@ -16,9 +16,9 @@ require_relative './empty_listener'
 require_relative './forward_context_methods'
 require_relative './test_logging'
 require_relative './runner_logging'
-require_relative './runner'
-require_relative './thread_context'
-require_relative './thread_pool'
+require_relative './runner/test_runner'
+require_relative './runner/thread_context'
+require_relative './runner/test_generator'
 require_relative './test/base'
 require_relative './page'
 require_relative './version'
@@ -28,7 +28,6 @@ require_relative './reporting/listeners/console'
 require_relative './reporting/listeners/console_dots'
 require_relative './reporting/listeners/junit_xml'
 require_relative './reporting/listeners/webui'
-require_relative './test_generator'
 require_relative './exceptions/moto'
 require_relative './exceptions/test_skipped'
 require_relative './exceptions/test_forced_failure'
@@ -39,7 +38,6 @@ module Moto
   class Cli
     def self.run(argv)
       test_paths_absolute = []
-      test_classes = []
 
       unless argv[ :tests ].nil?
         argv[ :tests ].each do |dir_name|
@@ -76,14 +74,9 @@ module Moto
         initializer.init
       end
 
-      tg = TestGenerator.new(MotoApp::DIR)
-      test_paths_absolute.each do |test_path|
-        test_classes << tg.generate(test_path)
-      end
-
-      @test_reporter = Moto::Reporting::TestReporter.new(argv[:listeners], argv[:config], argv[:name])
+      test_reporter = Moto::Reporting::TestReporter.new(argv[:listeners], argv[:config], argv[:name])
 
-      runner = Moto::Runner.new(test_classes, argv[:environments], argv[:config], @test_reporter)
+      runner = Moto::Runner::TestRunner.new(test_paths_absolute, argv[:environments], argv[:config], test_reporter)
       runner.run
     end
 

data/lib/clients/website.rb

@@ -17,11 +17,11 @@ module Moto
 
       def start_run
         # TODO: make session driver configurable
-        if context.runner.my_config[:capybara][:default_selector]
-          Capybara.default_selector = context.runner.my_config[:capybara][:default_selector]
+        if context.moto_app_config[:capybara][:default_selector]
+          Capybara.default_selector = context.moto_app_config[:capybara][:default_selector]
         end
 
-        Thread.current['capybara_session'] = Capybara::Session.new(context.runner.my_config[:capybara][:default_driver])
+        Thread.current['capybara_session'] = Capybara::Session.new(context.moto_app_config[:capybara][:default_driver])
         @pages = {}
       end
 
@@ -53,7 +53,7 @@ module Moto
       private
 
       def register_grid_driver
-        grid_config = context.runner.my_config[:capybara][:grid]
+        grid_config = context.moto_app_config[:capybara][:grid]
         return if grid_config.nil?
         if grid_config[:capabilities].nil?
           capabilities = Selenium::WebDriver::Remote::Capabilities.firefox

data/lib/forward_context_methods.rb

@@ -1,21 +1,24 @@
-module Moto
-  module ForwardContextMethods
-
-      def client(name)
-        @context.client(name)
-      end
-      
-      def logger
-        @context.logger
-      end
-      
-      def const(key)
-        @context.const(key)
-      end
-      
-      def current_test
-        @context.current_test
-      end
-   
-  end
+module Moto
+  module ForwardContextMethods
+      # Access client object instance for given class name.
+      def client(name)
+        @context.client(name)
+      end
+
+      # Write message to test execution log file. See Ruby Logger class for details.
+      def logger
+        @context.logger
+      end
+
+      # Read const value specific for current environment from `config/const.yml` file
+      def const(key)
+        @context.const(key)
+      end
+
+      # Access currently executed test
+      def test
+        @context.test
+      end
+   
+  end
 end

data/lib/parser.rb

@@ -7,7 +7,7 @@ require_relative '../lib/app_generator'
 module Moto
 
   class Parser
-  
+
     def self.run(argv)
       begin
 
@@ -26,7 +26,7 @@ module Moto
         puts e.backtrace.join("\n")
       end
     end
-    
+
     def self.run_parse(argv)
 
       # TODO: fix this dumb verification of current working directory.
@@ -34,11 +34,11 @@ module Moto
         msg = "Config file (config/moto.rb) not present.\n"
         msg << 'Does current working directory contain Moto application?'
         raise msg
-      end    
+      end
 
       require 'bundler/setup'
       Bundler.require
-      
+
       # Default options
       options = {}
       options[:listeners] = []
@@ -46,33 +46,33 @@ module Moto
       options[:config] = eval(File.read("#{MotoApp::DIR}/config/moto.rb"))
       options[:environments] = []
       options[:name] = ''
-         
+
       # Parse arguments
       # TODO eval ?
       # TODO const 
-      # TODO reporters should be consts - not strings
+      # TODO listeners should be consts - not strings
       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('-l', '--listeners Listeners', Array) { |v| options[:listeners] = v }
+        opts.on('-t', '--tests Tests', Array)              { |v| options[:tests ] = v }
+        opts.on('-g', '--tags Tags', Array)                { |v| options[:tags ] = v }
+        opts.on('-l', '--listeners Listeners', Array)      { |v| options[:listeners] = v }
         opts.on('-e', '--environments Environment', Array) { |v| options[:environments] = v }
-        opts.on('-c', '--const Const') { |v| options[:const] = v }
-        opts.on('-n', '--name Name') { |v| options[:name] = v }
-        opts.on('-f', '--config Config') { |v| options[:config].deep_merge!( eval( File.read(v) ) ) }
+        opts.on('-c', '--const Const')                     { |v| options[:const] = v }
+        opts.on('-n', '--name Name')                       { |v| options[:name] = v }
+        opts.on('-f', '--config Config')                   { |v| options[:config].deep_merge!( eval( File.read(v) ) ) }
       end.parse!
 
       if options[:name].empty?
         options[:name] = evaluate_name(options[:tags], options[:tests])
       end
 
-      if options[ :config ][ :moto ][ :runner ][ :mandatory_environment ] && options[ :environments ].empty?
+      if options[ :config ][ :moto ][ :test_runner ][ :mandatory_environment ] && options[ :environments ].empty?
         puts 'Environment is mandatory for this project.'
         exit 1
       end
 
       return options
     end
-    
+
     def self.evaluate_name(tags, tests)
       tags ||= ''
       tests ||= ''
@@ -104,19 +104,20 @@ module Moto
 
       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.
-                        For eg. Tests\Failure\Failure.rb should be passed as Tests::Failure
-       -r, --reporter = Reporters to be used.
-                        Defaults are Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml
+       -t, --tests     = Tests to be executed.
+                         For eg. Tests\Failure\Failure.rb should be passed as Tests::Failure
+       -l, --listeners = Reporters to be used.
+                         Defaults are Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml
        -e, --environment etc etc
 
+
       moto generate:
        -t, --test      = Path and name of the test to be created.
                          Examples:
@@ -133,6 +134,6 @@ module Moto
                          You have been warned.
       """
     end
-    
+
   end
 end

data/lib/reporting/listeners/console.rb

@@ -4,7 +4,7 @@ module Moto
       class Console < Base
 
         def start_run
-          puts 'START'
+         # puts 'START'
         end
 
         def end_run(run_status)
@@ -18,11 +18,11 @@ module Moto
         end
 
         def start_test(test_status)
-          print test_status.name
+         # puts test_status.name
         end
 
         def end_test(test_status)
-          puts "\t#{test_status.to_s}"
+          puts "\n#{test_status.name}\n\t#{test_status.results.last.message}"
         end
 
       end

data/lib/reporting/listeners/console_dots.rb

@@ -28,7 +28,7 @@ module Moto
             puts 'ERRORS: '
             run_status.tests_error.each do |test_status|
               puts test_status.name
-              puts test_status.results.last.message
+              puts "\t" + test_status.results.last.message
               puts ''
             end
           end
@@ -38,7 +38,7 @@ module Moto
             puts 'SKIPPED: '
             run_status.tests_skipped.each do |test_status|
               puts test_status.name
-              puts test_status.results.last.message
+              puts "\t" + test_status.results.last.message
               puts ''
             end
           end

data/lib/reporting/test_reporter.rb

@@ -12,7 +12,7 @@ module Moto
       def initialize(listeners, config, custom_run_name)
 
         if listeners.empty?
-          config[:moto][:runner][:default_listeners].each do |listener_class_name|
+          config[:moto][:test_runner][:default_listeners].each do |listener_class_name|
             listeners << listener_class_name
           end
         else

data/lib/runner/test_generator.rb

@@ -0,0 +1,165 @@
+module MotoApp
+  module Tests
+  end
+end
+
+module Moto
+  module Runner
+    class TestGenerator
+
+      def initialize(environments)
+        @internal_counter = 0
+        @environments = environments
+      end
+
+      # Method returns an array of test instances that represent all variants (parameter sets from test's config).
+      #   Example: A test with no config file will be returned as an array with single Moto::Test::Base in it.
+      #   Example: A test with a config file and 2 sets of parameters there will be returned as array with two elements.
+      #
+      # @param [String] test_path_absolute Path to the test that is about to be instantiated.
+      # @return [Array] An array of [Moto::Test::Base] decendants
+      #                 each entry is a Test with set of parameters injected
+      def get_test_with_variants(test_path_absolute)
+        test_path_absolute ? variantize(test_path_absolute) : nil
+      end
+
+      # Converts test's path to an array of Moto::Base::Test instances that represent all test variants (params, envs)
+      #
+      # *IMPORTANT*
+      # Config files with ruby code will be evaluated thus if you use any classes in them
+      # they must be required prior to that. That might be done in overloaded app's initializer.
+      #
+      # @param [String] test_path_absolute Path to the file with test
+      # @return [Array] array of already initialized test's variants
+      def variantize(test_path_absolute)
+        variants = []
+
+          @environments.each do |env|
+            params_path = test_path_absolute.sub(/\.rb\z/, '')
+
+            if File.exists?(params_path)
+              begin
+                params_all = eval(File.read(params_path))
+              rescue Exception => e
+                puts "Parameters error:\n\t File:  #{params_path}\n\t Error: #{e.message}\n\n"
+              end
+            else
+              params_all = [{}]
+            end
+
+            params_all.each_with_index do |params, params_index|
+
+              # Filtering out param sets that are specific to certain envs
+              unless params['__env'].nil?
+                allowed_envs = params['__env'].is_a?(String) ? [params['__env']] : params['__env']
+                next unless allowed_envs.include? env
+              end
+
+              test = generate(test_path_absolute)
+              test.init(env, params, params_index, @internal_counter)
+              test.log_path = "#{test.dir}/logs/#{test.name.gsub(/[^0-9A-Za-z.\-]/, '_')}.log"
+              @internal_counter += 1
+              variants << test
+            end
+          end
+
+        variants
+      end
+      private :variantize
+
+      # assuming that target file includes only content of method 'run' and some magic comments
+      def generate(test_path_absolute)
+        method_body = File.read(test_path_absolute) + "\n"
+
+        full_code = !!method_body.match(/^#\s*FULL_CODE\s+/)
+
+        if full_code
+          generate_for_full_class_code(test_path_absolute)
+        else
+          generate_for_run_body(test_path_absolute, method_body)
+        end
+      end
+      private :generate
+
+      # Generates test instances, based on fully defined class file
+      # @return [Moto::Test::Base]
+      def generate_for_full_class_code(test_path_absolute)
+        require test_path_absolute
+
+        test_object = nil
+
+        # Checking if it's possible to create test based on provided path. In case something is wrong with
+        # modules structure in class itself Moto::Test::Base will be instantized with raise injected into its run()
+        # so we can have proper reporting and summary even if the test doesn't execute.
+        begin
+          class_name = test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb').constantize
+          test_object = class_name.new
+        rescue NameError
+          class_name = Moto::Test::Base
+          test_object = class_name.new
+
+          class << test_object
+            attr_accessor :custom_name
+
+            def run
+              raise "ERROR: Invalid module structure: #{custom_name}"
+            end
+          end
+
+          test_object.custom_name = test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb')
+        end
+
+        test_object.static_path = test_path_absolute
+        test_object.evaled = false
+        test_object
+      end
+      private :generate_for_full_class_code
+
+      def create_module_tree(root_module, next_modules)
+        return root_module if next_modules.empty?
+        next_module_name = next_modules.shift
+        if root_module.const_defined?(next_module_name.to_sym)
+          m = root_module.const_get(next_module_name.to_sym)
+        else
+          m = Module.new
+          root_module.const_set(next_module_name.to_sym, m)
+        end
+        create_module_tree(m, next_modules)
+      end
+      private :create_module_tree
+
+      # Generates test instances, based on a text file with ruby code that has to be injected into run() method
+      # @return [Moto::Test::Base]
+      def generate_for_run_body(test_path_absolute, method_body)
+        base = Moto::Test::Base
+        base_class_string = method_body.match(/^#\s*BASE_CLASS:\s(\S+)/)
+        unless base_class_string.nil?
+          base_class_string = base_class_string[1].strip
+
+          a = base_class_string.underscore.split('/')
+          base_test_path = a[1..-1].join('/')
+
+          require "#{MotoApp::DIR}/#{base_test_path}"
+          base = base_class_string.constantize
+        end
+
+        # MotoApp::Tests::Login::Short
+        consts = test_path_absolute.camelize.split('Tests::')[1].split('::')
+        consts.pop
+        class_name = consts.pop
+
+        m = create_module_tree(MotoApp::Tests, consts)
+        cls = Class.new(base)
+        m.const_set(class_name.to_sym, cls)
+
+        test_object = cls.new
+        test_object.instance_eval("def run\n  #{method_body} \n end")
+        test_object.static_path = test_path_absolute
+        test_object.evaled = true
+        test_object
+      end
+      private :generate_for_run_body
+
+    end
+  end
+end

data/lib/runner/test_provider.rb

@@ -0,0 +1,69 @@
+require 'thread'
+require_relative 'test_generator'
+
+module Moto
+  module Runner
+    # Thread safe provider of test instances
+    class TestProvider
+
+      # @param [Array] test_paths_absolute
+      # @param [Array] environments Array
+      # @param [Integer] test_repeats
+      def initialize(test_paths_absolute, environments, test_repeats)
+        super()
+        @test_repeats = test_repeats
+        @current_test_repeat = 1
+        @queue = Queue.new
+        @test_paths_absolute = test_paths_absolute
+        @test_generator = TestGenerator.new(environments)
+      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_variants = @test_generator.get_test_with_variants(get_test_path)
+
+          if test_variants
+            test_variants.each do |test|
+              @queue.push(test)
+            end
+          end
+
+        end
+      end
+      private :create_tests
+
+      # Returns path to the test while supporting the number of repeats specified by the user
+      # return [String] Path to the test
+      def get_test_path
+
+        if @current_test_repeat == 1
+          @test_path = @test_paths_absolute.shift
+        end
+
+        if @current_test_repeat == @test_repeats
+          @current_test_repeat = 1
+        else
+          @current_test_repeat += 1
+        end
+
+        @test_path
+      end
+      private :get_test_path
+
+      # Number of threads waiting for a job
+      def num_waiting
+        @queue.num_waiting
+      end
+
+    end
+  end
+end
+

data/lib/runner/test_runner.rb

@@ -0,0 +1,65 @@
+require_relative '../reporting/test_reporter'
+require_relative './test_provider'
+
+module Moto
+  module Runner
+    class TestRunner
+
+      attr_reader :logger
+      attr_reader :config
+      attr_reader :test_reporter
+
+      def initialize(test_paths_absolute, environments, config, test_reporter)
+        @test_paths_absolute = test_paths_absolute
+        @config = config
+        @test_reporter = test_reporter
+
+        # TODO: initialize logger from config (yml or just ruby code)
+        @logger = Logger.new(File.open("#{MotoApp::DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
+
+        @environments = environments.empty? ? environments << :__default : environments
+      end
+
+      def running_thread_count
+        Thread.list.select {|thread| thread.status == "run"}.count
+      end
+
+      def run
+        test_provider = TestProvider.new(@test_paths_absolute, @environments, @config[:moto][:test_runner][:test_repeats])
+        threads_max = @config[:moto][:test_runner][:thread_count] || 1
+
+        # remove log/screenshot files from previous execution
+        @test_paths_absolute.each do |test_path|
+          FileUtils.rm_rf("#{File.dirname(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.
+        (1..threads_max).each do |index|
+          Thread.new do
+            Thread.current[:id] = index
+            loop do
+              tc = ThreadContext.new(@config, 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
+        loop do
+          if test_provider.num_waiting == threads_max
+            break
+          end
+
+          sleep 1
+        end
+
+        @test_reporter.report_end_run
+      end
+
+    end
+  end
+end

data/lib/runner/thread_context.rb

@@ -0,0 +1,146 @@
+require 'erb'
+require 'fileutils'
+
+module Moto
+  module Runner
+    class ThreadContext
+
+      # all resources specific for single thread will be initialized here. E.g. browser session
+      attr_reader :logger
+      attr_reader :test
+      attr_reader :moto_app_config
+
+      def initialize(config, test, test_reporter)
+        @config = config
+        @test = test
+        @clients = {}
+        @test.context = self
+        @test_reporter = test_reporter
+
+        # TODO: temporary fix
+        Thread.current['context'] = self
+
+        # TODO: temporary fix
+        @moto_app_config = {}
+        Dir.glob('config/*.yml').each do |f|
+          @moto_app_config.deep_merge! YAML.load_file(f)
+        end
+      end
+
+      def client(name)
+        return @clients[name] if @clients.key? name
+
+        name_app = 'MotoApp::Lib::Clients::' + name
+        name_moto = 'Moto::Clients::' + name
+
+        c = try_client(name_app, "#{MotoApp::DIR}/")
+        unless c.nil?
+          @clients[name] = c
+          return c
+        end
+
+        c = try_client(name_moto, "#{Moto::DIR}/lib")
+        unless c.nil?
+          @clients[name] = c
+          return c
+        end
+        raise "Could not find client class for name #{name}"
+      end
+
+      def try_client(name, dir)
+        begin
+          a = name.underscore.split('/')
+          client_path = a[1..-1].join('/')
+          require "#{dir}/#{client_path}"
+          client_const = name.constantize
+          instance = client_const.new(self)
+          instance.init
+          instance.start_run
+          instance.start_test(@test)
+          return instance
+        rescue Exception => e
+          # puts e
+          # puts e.backtrace
+          return nil
+        end
+      end
+
+      def const(key)
+        key = key.to_s
+        key = "#{@test.env.to_s}.#{key}" if @test.env != :__default
+        code = if key.include? '.'
+                 "@moto_app_config#{key.split('.').map { |a| "['#{a}']" }.join('')}"
+               else
+                 "@moto_app_config['#{key}']"
+               end
+        begin
+          v = eval code
+          raise if v.nil?
+        rescue
+          raise "There is no const defined for key: #{key}. Environment: #{ (@test.env == :__default) ? '<none>' : @test.env }"
+        end
+        v
+      end
+
+      def run
+        max_attempts = @config[:moto][:thread_context][:max_attempts] || 1
+        sleep_time = @config[:moto][:thread_context][:sleep_before_attempt] || 0
+
+        log_directory = File.dirname(@test.log_path)
+        if !File.directory?(log_directory)
+          FileUtils.mkdir_p(log_directory)
+        end
+
+        @logger = Logger.new(File.open(@test.log_path, File::WRONLY | File::TRUNC | File::CREAT))
+        @logger.level = @config[:moto][:thread_context][:log_level] || Logger::DEBUG
+
+        # Reporting: start_test
+        @test_reporter.report_start_test(@test.status)
+
+        (1..max_attempts).each do |attempt|
+
+          @clients.each_value { |c| c.start_test(@test) }
+          @test.before
+          @logger.info "Start: #{@test.name} attempt #{attempt}/#{max_attempts}"
+
+          begin
+            @test.run_test
+          rescue Exceptions::TestForcedPassed, Exceptions::TestForcedFailure, Exceptions::TestSkipped => e
+            @logger.info(e.message)
+          rescue Exception => e
+            @logger.error("#{e.class.name}: #{e.message}")
+            @logger.error(e.backtrace.join("\n"))
+            @clients.each_value { |c| c.handle_test_exception(@test, e) }
+          end
+
+          @test.after
+          @clients.each_value { |c| c.end_test(@test) }
+
+          @logger.info("Result: #{@test.status.results.last.code}")
+
+          # test should have another attempt only in case of an error
+          # pass, skip and fail statuses end attempts
+          if @test.status.results.last.code != Moto::Test::Result::ERROR
+            break
+          end
+
+          # don't go to sleep in the last attempt
+          if attempt < max_attempts
+            sleep sleep_time
+          end
+
+        end # Make another attempt
+
+        # Close and flush stream to file
+        @logger.close
+
+        # Reporting: end_test
+        @test_reporter.report_end_test(@test.status)
+
+        @clients.each_value { |c| c.end_run }
+
+      end
+
+    end
+  end
+end

data/lib/test/base.rb

@@ -27,10 +27,10 @@ module Moto
       end
 
       # Initializes test to be executed with specified params and environment
-      def init(env, params, params_index)
+      def init(env, params, params_index, global_index)
         @env = env
         @params = params
-        @name = generate_name(params_index)
+        @name = generate_name(params_index, global_index)
 
         @status = Moto::Test::Status.new
         @status.name = @name
@@ -42,16 +42,19 @@ module Moto
       # Generates name of the test based on its properties:
       #  - number/name of currently executed configuration run
       #  - env
-      def generate_name(params_index)
+      def generate_name(params_index, global_index)
+        simple_class_name = self.class.to_s.demodulize
+
         if @env == :__default
-          return "#{self.class.to_s}" if @params.empty?
-          return "#{self.class.to_s}/#{@params['__name']}" if @params.key?('__name')
-          return "#{self.class.to_s}/params_#{params_index}" unless @params.key?('__name')
+          return "#{simple_class_name}_#{global_index}" if @params.empty?
+          return "#{simple_class_name}_#{@params[:__name]}_#{global_index}" if @params.key?(:__name)
+          return "#{simple_class_name}_P#{params_index}_#{global_index}" unless @params.key?(:__name)
         else
-          return "#{self.class.to_s}/#{@env}" if @params.empty?
-          return "#{self.class.to_s}/#{@env}/#{@params['__name']}" if @params.key?('__name')
-          return "#{self.class.to_s}/#{@env}/params_#{params_index}" unless @params.key?('__name')
+          return "#{simple_class_name}_#{@env}_##{global_index}" if @params.empty?
+          return "#{simple_class_name}_#{@env}_#{@params[:__name]}_#{global_index}" if @params.key?(:__name)
+          return "#{simple_class_name}_#{@env}_P#{params_index}_#{global_index}" unless @params.key?(:__name)
         end
+
         self.class.to_s
       end
       private :generate_name

data/lib/test_logging.rb

@@ -36,10 +36,10 @@ module Moto
               end
             end
           end
-          @context.current_test.logger.debug("ENTER >>> #{self.class.name}::#{__callee__}(#{args})") unless skip_logging
+          @context.test.logger.debug("ENTER >>> #{self.class.name}::#{__callee__}(#{args})") unless skip_logging
           result = send original_method, *args
           # Below is the hack to properly escape binary data (if any manages to make it to logs)
-          @context.current_test.logger.debug("LEAVE <<< #{self.class.name}::#{__callee__} => #{[result].to_s[1..-2]}") unless skip_logging
+          @context.test.logger.debug("LEAVE <<< #{self.class.name}::#{__callee__} => #{[result].to_s[1..-2]}") unless skip_logging
           result
         end
         @added = false

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Moto
-  VERSION = '0.0.33'
+  VERSION = '0.0.40'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.33
+  version: 0.0.40
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
+date: 2016-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -104,15 +104,15 @@ files:
 - lib/reporting/listeners/webui.rb
 - lib/reporting/run_status.rb
 - lib/reporting/test_reporter.rb
-- lib/runner.rb
+- lib/runner/test_generator.rb
+- lib/runner/test_provider.rb
+- lib/runner/test_runner.rb
+- lib/runner/thread_context.rb
 - lib/runner_logging.rb
 - lib/test/base.rb
 - lib/test/result.rb
 - lib/test/status.rb
-- lib/test_generator.rb
 - lib/test_logging.rb
-- lib/thread_context.rb
-- lib/thread_pool.rb
 - lib/version.rb
 homepage: https://github.com/bwilczek/moto
 licenses:

data/lib/runner.rb

@@ -1,62 +0,0 @@
-require_relative './reporting/test_reporter'
-
-module Moto
-  class Runner
-
-    attr_reader :logger
-    attr_reader :environments
-    attr_reader :assert
-    attr_reader :config
-    attr_reader :name
-    attr_reader :test_reporter
-
-    def initialize(tests, environments, config, test_reporter)
-      @tests = tests
-      @config = config
-      @thread_pool = ThreadPool.new(my_config[:thread_count] || 1)
-      @test_reporter = test_reporter
-
-      # TODO: initialize logger from config (yml or just ruby code)
-      # @logger = Logger.new(STDOUT)
-      @logger = Logger.new(File.open("#{MotoApp::DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
-      # @logger.level = Logger::WARN
-
-      # TODO: validate envs, maybe no-env should be supported as well?
-      environments << :__default if environments.empty?
-      @environments = environments
-    end
-
-    # TODO: Remake
-    # @return [Hash] hash with config
-    def my_config
-      caller_path = caller.first.to_s.split(/:\d/)[0]
-      keys = []
-      if caller_path.include? MotoApp::DIR
-        caller_path.sub!( "#{MotoApp::DIR}/lib/", '' )
-        keys << 'moto_app'
-      elsif caller_path.include? Moto::DIR
-        caller_path.sub!( "#{Moto::DIR}/lib/", '' )
-        keys << 'moto'
-      end
-      caller_path.sub!('.rb', '')
-      keys << caller_path.split('/')
-      keys.flatten!
-      eval "@config#{keys.map{|k| "[:#{k}]" }.join('')}"
-    end
-
-    def run
-      @test_reporter.report_start_run
-
-      @tests.each do |test|
-        @thread_pool.schedule do
-          tc = ThreadContext.new(self, test, @test_reporter)
-          tc.run
-        end
-      end
-
-      @thread_pool.shutdown
-      @test_reporter.report_end_run
-    end
-
-  end
-end

data/lib/test_generator.rb

@@ -1,112 +0,0 @@
-module MotoApp
-  module Tests
-  end
-end
-
-module Moto
-  class TestGenerator
-    
-    def initialize(app_dir)
-      @app_dir = app_dir
-    end
-    
-    # assuming that target file includes full valid ruby class
-    def create(class_name)
-      class_name = 'MotoApp::Tests::'+class_name
-      a = class_name.underscore.split('/')
-      test_path = (a[1..20]+[a[-1]]).join('/')
-      
-      # TODO: check if this path and constant exists
-      require "#{MotoApp::DIR}/#{test_path}"
-      test_const = class_name.safe_constantize  
-      test_const.new
-    end
-    
-    def create_module_tree(root_module, next_modules)
-      return root_module if next_modules.empty?
-      next_module_name = next_modules.shift
-      if root_module.const_defined?(next_module_name.to_sym)
-        m = root_module.const_get(next_module_name.to_sym)
-      else
-        m = Module.new
-        root_module.const_set(next_module_name.to_sym, m)
-      end
-      create_module_tree(m, next_modules)
-    end
-    
-    # assuming that target file includes only content of method 'run' and some magic comments
-    def generate(test_path_absolute)
-      method_body = File.read(test_path_absolute) + "\n"
-
-      full_code = !! method_body.match( /^#\s*FULL_CODE\s+/ )
-
-      if full_code
-        generate_for_full_class_code(test_path_absolute)
-      else
-        generate_for_run_body(test_path_absolute, method_body)
-      end
-    end
-
-    # Generates objects with tests that are supposed to be executed in this run.
-    def generate_for_full_class_code(test_path_absolute)
-      require test_path_absolute
-
-      test_object = nil
-
-      # Checking if it's possible to create test based on provided path. In case something is wrong with
-      # modules structure in class itself Moto::Test::Base will be instantized with raise injected into its run()
-      # so we can have proper reporting and summary even if the test doesn't execute.
-      begin
-        class_name = test_path_absolute.gsub("#{MotoApp::DIR}/",'moto_app/').camelize.chomp('.rb').constantize
-        test_object = class_name.new
-      rescue NameError
-        class_name = Moto::Test::Base
-        test_object = class_name.new
-
-        class << test_object
-          attr_accessor :custom_name
-
-          def run
-            raise "ERROR: Invalid module structure: #{custom_name}"
-          end
-        end
-
-        test_object.custom_name = test_path_absolute.gsub("#{MotoApp::DIR}/",'moto_app/').camelize.chomp('.rb')
-      end
-
-      test_object.static_path = test_path_absolute
-      test_object.evaled = false
-      test_object
-    end
-
-    def generate_for_run_body(test_path_absolute, method_body)
-      base = Moto::Test::Base
-      base_class_string = method_body.match( /^#\s*BASE_CLASS:\s(\S+)/ )
-      unless base_class_string.nil?
-        base_class_string = base_class_string[1].strip
-        
-        a = base_class_string.underscore.split('/')
-        base_test_path = a[1..-1].join('/')
-        
-        require "#{MotoApp::DIR}/#{base_test_path}"
-        base = base_class_string.constantize
-      end
-
-      # MotoApp::Tests::Login::Short
-      consts = test_path_absolute.camelize.split('Tests::')[1].split('::')
-      consts.pop
-      class_name = consts.pop
-
-      m = create_module_tree(MotoApp::Tests, consts)
-      cls = Class.new(base)
-      m.const_set(class_name.to_sym, cls)
-      
-      test_object = cls.new
-      test_object.instance_eval( "def run\n  #{method_body} \n end" )
-      test_object.static_path = test_path_absolute
-      test_object.evaled = true        
-      test_object
-    end
-    
-  end
-end

data/lib/thread_context.rb

@@ -1,162 +0,0 @@
-require 'erb'
-
-module Moto
-  class ThreadContext
-
-    # all resources specific for single thread will be initialized here. E.g. browser session
-    attr_reader :runner
-    attr_reader :logger
-    attr_reader :current_test
-
-    def initialize(runner, test, test_reporter)
-      @runner = runner
-      @test = test
-      @clients = {}
-      @test.context = self
-      @test_reporter = test_reporter
-
-      #TODO temporary fix
-      Thread.current['context']= self
-
-      @config = {}
-      Dir.glob("config/*.yml").each do |f|
-        @config.deep_merge! YAML.load_file(f)
-      end
-    end
-
-    def client(name)
-      return @clients[name] if @clients.key? name
-
-      name_app = 'MotoApp::Lib::Clients::' + name
-      name_moto = 'Moto::Clients::' + name
-
-      c = try_client(name_app, "#{MotoApp::DIR}/")
-      unless c.nil?
-        @clients[name] = c
-        return c
-      end
-
-      c = try_client(name_moto, "#{Moto::DIR}/lib")
-      unless c.nil?
-        @clients[name] = c
-        return c
-      end
-      raise "Could not find client class for name #{name}"
-    end
-
-    def try_client(name, dir)
-      begin
-        a = name.underscore.split('/')
-        client_path = a[1..-1].join('/')
-        require "#{dir}/#{client_path}"
-        client_const = name.constantize
-        instance = client_const.new(self)
-        instance.init
-        instance.start_run
-        instance.start_test(@current_test)
-        return instance
-      rescue Exception => e
-        # puts e
-        # puts e.backtrace
-        return nil
-      end
-    end
-
-    def const(key)
-      key = key.to_s
-      key = "#{@current_test.env.to_s}.#{key}" if @current_test.env != :__default
-      code = if key.include? '.'
-               "@config#{key.split('.').map { |a| "['#{a}']" }.join('')}"
-             else
-               "@config['#{key}']"
-             end
-      begin
-        v = eval code
-        raise if v.nil?
-      rescue
-        raise "There is no const defined for key: #{key}. Environment: #{ (@current_test.env == :__default) ? '<none>' : @current_test.env }"
-      end
-      v
-    end
-
-    def run
-      # remove log/screenshot files from previous execution
-      Dir.glob("#{@test.dir}/*.{log,png}").each { |f| File.delete f }
-      max_attempts = @runner.my_config[:max_attempts] || 1
-      sleep_time = @runner.my_config[:sleep_before_attempt] || 0
-
-      @runner.environments.each do |env|
-        params_all = [{}]
-
-        # RB Config files
-        params_path = "#{@test.dir}/#{@test.filename}"
-        params_all = eval(File.read(params_path)) if File.exists?(params_path)
-
-        params_all.each_with_index do |params, params_index|
-
-          # Filtering out param sets that are specific to certain envs
-          unless params['__env'].nil?
-            allowed_envs = params['__env'].is_a?(String) ? [params['__env']] : params['__env']
-            next unless allowed_envs.include? env
-          end
-
-          @test.init(env, params, params_index)
-          # @test.log_path = "#{@test.dir}/#{@test.name.gsub(/\s+/, '_').gsub(':', '_').gsub('::', '_').gsub('/', '_')}.log"
-          @test.log_path = "#{@test.dir}/#{@test.name.demodulize.gsub('/', '_')}.log"
-          # TODO: log path might be specified (to some extent) by the configuration
-          @logger = Logger.new(File.open(@test.log_path, File::WRONLY | File::TRUNC | File::CREAT))
-          @logger.level = @runner.my_config[:log_level] || Logger::DEBUG
-          @current_test = @test
-
-          (1..max_attempts).each do |attempt|
-
-            # Reporting: start_test
-            if attempt == 1
-              @test_reporter.report_start_test(@test.status)
-            end
-
-            @clients.each_value { |c| c.start_test(@test) }
-            @test.before
-            @logger.info "Start: #{@test.name} attempt #{attempt}/#{max_attempts}"
-
-            begin
-              @test.run_test
-            rescue  Exceptions::TestForcedPassed, Exceptions::TestForcedFailure, Exceptions::TestSkipped => e
-              @logger.info(e.message)
-            rescue Exception => e
-              @logger.error("#{e.class.name}: #{e.message}")
-              @logger.error(e.backtrace.join("\n"))
-              @clients.each_value { |c| c.handle_test_exception(@test, e) }
-            end
-
-            @test.after
-            @clients.each_value { |c| c.end_test(@test) }
-
-            @logger.info("Result: #{@test.status.results.last.code}")
-
-            # test should have another attempt only in case of an error
-            # pass, skip and fail statuses end attempts
-            if @test.status.results.last.code != Moto::Test::Result::ERROR
-              break
-            end
-
-            # don't go to sleep in the last attempt
-            if attempt < max_attempts
-              sleep sleep_time
-            end
-
-          end # Make another attempt
-
-          # Close and flush stream to file
-          @logger.close
-
-          # Reporting: end_test
-          @test_reporter.report_end_test(@test.status)
-
-        end
-      end
-      @clients.each_value { |c| c.end_run }
-    end
-
-  end
-end

data/lib/thread_pool.rb

@@ -1,32 +0,0 @@
-module Moto
-  class ThreadPool
-
-    def initialize(size=1)
-      @size = size
-      @jobs = Queue.new
-      @pool = Array.new(@size) do |i|
-        Thread.new do
-          Thread.current[:id] = i
-          catch(:exit) do
-            loop do
-              job, args = @jobs.pop
-              job.call(*args)
-            end
-          end
-        end
-      end
-    end
-
-    def schedule(*args, &block)
-      @jobs << [block, args]
-    end
-
-    def shutdown
-      @size.times do
-        schedule { throw :exit }
-      end
-      @pool.each(&:join)
-    end
-
-  end
-end