moto 0.0.61 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79fd340e02c8fc99118145bfff406152d69616b4
-  data.tar.gz: 0409af8e817650b861ff323af7fd2d4689adffa5
+  metadata.gz: 5c6fc26ad79a37b98a47def96713f98aeb645d7a
+  data.tar.gz: 319b20fd048182b400a165c5f947eca5da265850
 SHA512:
-  metadata.gz: aff3af12f4ce522fd01d733556a3a9b04c6ef155edbbbcadd7556ae00a8d0c4d38da9946907df1094f2b6e806fd79695a13877c2626ff08876faceb7ee5b82bc
-  data.tar.gz: fa8bdff3222419dda771bee36e38615c50008d87ba500a8905ae010ac133b5f1591846b21ff9d6c2d037c15a838c0b3215b2b4cf2e1d087a87905048763c1a6d
+  metadata.gz: b7094905897ffa05fd13dcc0e170d3f9a9faf54b76a27aaff5776f353d664c035f786bab3fe9b8585ce594584a3c03c88f1d852e35e991787eb5eece832134dc
+  data.tar.gz: 8fb71b7424b346314b29cd76f232207db2fc3f19214adfbbbd3e2f9239896e8610b568ca3e192759e2ed87bb649b2971059a7f9098db31cb2f82cc9cdb885b92

data/lib/cli.rb

@@ -13,7 +13,6 @@ module Moto
 end
 
 require_relative './empty_listener'
-require_relative './forward_context_methods'
 require_relative './test_logging'
 require_relative './runner_logging'
 require_relative './runner/test_runner'

data/lib/clients/base.rb

@@ -3,23 +3,12 @@ module Moto
 
     class Base
       include Moto::EmptyListener
-      include Moto::ForwardContextMethods
 
       # include Moto::RunnerLogging
       include Moto::TestLogging
 
-      attr_reader :context
-
       ignore_logging(:handle_test_exception)
 
-      def initialize(context)
-        @context = context
-      end
-
-      def init
-        # abstract
-      end
-
       def handle_test_exception(test, exception)
         # abstract
       end
@@ -31,6 +20,11 @@ module Moto
         Moto::Lib::Config.environment_const(key)
       end
 
+      # Access client defined in Moto or MotoApp via it's name
+      def client(name)
+        Thread.current['clients_manager'].client(name)
+      end
+
     end
   end
 end

data/lib/clients/clients_manager.rb

@@ -0,0 +1,51 @@
+module Moto
+  module Lib
+    module Clients
+      class ClientsManager
+
+        attr_reader :clients
+
+        def initialize
+          @clients = {}
+        end
+
+        def client(name)
+          return @clients[name] if @clients.key? name
+
+          name_app = 'MotoApp::Lib::Clients::' + name
+          name_moto = 'Moto::Clients::' + name
+
+          client = try_client(name_app, "#{MotoApp::DIR}/")
+          if client
+            @clients[name] = client
+            return client
+          end
+
+          client = try_client(name_moto, "#{Moto::DIR}/lib/")
+          if client
+            @clients[name] = client
+            return client
+          end
+
+          raise "Could not find client class for name: #{name}"
+        end
+
+        def try_client(name, dir)
+            client_path = name.underscore.split('/')[1..-1].join('/')
+
+            if File.file?(dir + client_path + '.rb')
+              require dir + client_path
+              client_const = name.constantize
+              instance = client_const.new
+              instance.start_run
+              instance
+            else
+              nil
+            end
+        end
+        private :try_client
+
+      end
+    end
+  end
+end

data/lib/clients/website.rb

@@ -6,15 +6,25 @@ module Moto
 
     class Website < Moto::Clients::Base
 
-      attr_reader :session
-
-      ignore_logging(:page)
-      ignore_logging(:context)
       ignore_logging(:session)
 
-      def init
+      def initialize
         register_grid_driver
         register_chrome_driver
+
+        if config[:default_selector]
+          Capybara.default_selector = config[:default_selector]
+        end
+      end
+
+      # Returns Capybara session, if none was available for this thread it will create one.
+      def session
+        if Thread.current['capybara_session'].nil?
+          Thread.current['capybara_session'] = Capybara::Session.new(config[:default_driver])
+          Thread.current['capybara_session'].driver.browser.manage.window.maximize
+        end
+
+        Thread.current['capybara_session']
       end
 
       # @return [Hash] Config section for Capybara driver.
@@ -24,13 +34,7 @@ module Moto
       private :config
 
       def start_run
-        # TODO: make session driver configurable
-        if config[:default_selector]
-          Capybara.default_selector = config[:default_selector]
-        end
 
-        Thread.current['capybara_session'] = Capybara::Session.new(config[:default_driver])
-        @pages = {}
       end
 
       def end_run
@@ -44,18 +48,6 @@ module Moto
       def end_test(test)
         Thread.current['capybara_session'].reset_session!
       end
-      #TODO fix moto to use Lib module
-      def page(p)
-        page_class_name = "#{self.class.name}::Pages::#{p}"
-        page_class_name.gsub!('Moto::', 'MotoApp::Lib::')
-        if @pages[page_class_name].nil?
-          a = page_class_name.underscore.split('/')
-          page_path = a[1..-1].join('/')
-          require "#{MotoApp::DIR}/#{page_path}"
-          @pages[page_class_name] = page_class_name.constantize.new(self)
-        end
-        @pages[page_class_name]
-      end
 
       def register_grid_driver
         grid_config = config[:grid]

data/lib/page.rb

@@ -1,23 +1,14 @@
 module Moto
-
   class Page
 
     include Moto::TestLogging
-    include Moto::ForwardContextMethods
 
     ignore_logging :const
     ignore_logging :session
 
-    attr_reader :website
-    attr_reader :context
-
-    def initialize(website)
-      @website = website
-      @context = @website.context
-    end
-
-    def page(p)
-      @context.client(@website.class.name.split('::').pop).page(p)
+    # Returns Capybara's session by means of on-the-fly client&session creation.
+    def session
+      Thread.current['clients_manager'].client('Website').session
     end
 
     def raise_unless_loaded

data/lib/runner/test_generator.rb

@@ -91,25 +91,18 @@ module Moto
       # Generates test instances, based on fully defined class file
       # @return [Moto::Test::Base]
       def generate_for_full_class_code(test_path_absolute)
-
-        begin
-          require test_path_absolute
-        rescue Exception
-          # will catch an error with non existent base class in test and stop it from breaking whole batch of tests
-          # no need to handle it here, next begin/rescue clause in this function will finish the job
-        end
-
         # 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
+          require test_path_absolute
           class_name = test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb').constantize
           test_object = class_name.new
-        rescue NameError
+        rescue NameError => e
           class_name = Moto::Test::Base
           test_object = class_name.new
 
-          error_message = "ERROR: Invalid module structure: #{test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb')}"
+          error_message = "ERROR: Invalid test: #{test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb')}.\nMESSAGE: #{e}"
           inject_error_to_test(test_object, error_message)
         end
 

data/lib/runner/test_runner.rb

@@ -5,15 +5,11 @@ module Moto
   module Runner
     class TestRunner
 
-      attr_reader :logger
       attr_reader :test_reporter
 
       def initialize(test_paths_absolute, test_reporter)
         @test_paths_absolute = test_paths_absolute
         @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))
       end
 
       def run
@@ -30,10 +26,15 @@ module Moto
         # 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
+              Thread.current['clients_manager'] = Moto::Lib::Clients::ClientsManager.new
+
               tc = ThreadContext.new(test_provider.get_test, @test_reporter)
               tc.run
             end

data/lib/runner/thread_context.rb

@@ -1,103 +1,58 @@
 require 'erb'
 require 'fileutils'
 require_relative '../../lib/config'
+require_relative '../../lib/clients/clients_manager'
 
 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
 
       def initialize(test, test_reporter)
         @test = test
-        @clients = {}
-        @test.context = self
         @test_reporter = test_reporter
 
-        # TODO: temporary fix
-        Thread.current['context'] = self
-      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
+        log_directory = File.dirname(@test.log_path)
+        if !File.directory?(log_directory)
+          FileUtils.mkdir_p(log_directory)
         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}"
+        Thread.current['logger'] = Logger.new(File.open(@test.log_path, File::WRONLY | File::TRUNC | File::CREAT))
+        Thread.current['logger'].level = config[:test_log_level] || Logger::DEBUG
       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 run
         max_attempts = config[:test_attempt_max]   || 1
         sleep_time   = config[:test_attempt_sleep] || 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[:test_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) }
+          Thread.current['clients_manager'].clients.each_value { |c| c.start_test(@test) }
           @test.before
-          @logger.info "Start: #{@test.name} attempt #{attempt}/#{max_attempts}"
+          Thread.current['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)
+            Thread.current['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) }
+            Thread.current['logger'].error("#{e.class.name}: #{e.message}")
+            Thread.current['logger'].error(e.backtrace.join("\n"))
+            Thread.current['clients_manager'].clients.each_value { |c| c.handle_test_exception(@test, e) }
           end
 
           @test.after
-          @clients.each_value { |c| c.end_test(@test) }
+          Thread.current['clients_manager'].clients.each_value { |c| c.end_test(@test) }
 
-          @logger.info("Result: #{@test.status.results.last.code}")
+          Thread.current['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
+          # test should have another attempt in case of an error / failure / none at all
+          if (@test.status.results.last.code == Moto::Test::Result::ERROR   && !Moto::Lib::Config.moto[:test_reattempt_on_error]) ||
+             (@test.status.results.last.code == Moto::Test::Result::FAILURE && !Moto::Lib::Config.moto[:test_reattempt_on_fail] )
             break
           end
 
@@ -109,12 +64,12 @@ module Moto
         end # Make another attempt
 
         # Close and flush stream to file
-        @logger.close
+        Thread.current['logger'].close
 
         # Reporting: end_test
         @test_reporter.report_end_test(@test.status)
 
-        @clients.each_value { |c| c.end_run }
+        Thread.current['clients_manager'].clients.each_value { |c| c.end_run }
 
       end
 

data/lib/runner_logging.rb

@@ -1,7 +1,6 @@
 module Moto
   module RunnerLogging
 
-
     # TODO: merge it somehow with TestLogging. Parametrize logger object?
     def self.included(cls)
       def cls.method_added(name)
@@ -14,9 +13,9 @@ module Moto
         original_method = "original_#{name}"
         alias_method original_method, name
         define_method(name) do |*args|
-          @context.runner.logger.debug("#{self.class.name}::#{__callee__} ENTER >>> #{args}") unless excluded_methods.include? name 
+          Thread.current['logger'].debug("#{self.class.name}::#{__callee__} ENTER >>> #{args}") unless excluded_methods.include? name
           result = send original_method, *args
-          @context.runner.logger.debug("#{self.class.name}::#{__callee__} LEAVE <<< #{result} ") unless excluded_methods.include? name
+          Thread.current['logger'].debug("#{self.class.name}::#{__callee__} LEAVE <<< #{result} ") unless excluded_methods.include? name
           result
         end
         @added = false

data/lib/test/base.rb

@@ -4,10 +4,7 @@ module Moto
   module Test
     class Base
 
-      include Moto::ForwardContextMethods
-
       attr_reader   :name
-      attr_writer   :context
       attr_reader   :env
       attr_reader   :params
       attr_accessor :static_path
@@ -156,7 +153,7 @@ module Moto
           end
 
           status.log_failure("ASSERTION FAILED in line #{line_number}: #{message}")
-          logger.error(message)
+          Thread.current['logger'].error(message)
         end
       end
 
@@ -167,6 +164,14 @@ module Moto
         Moto::Lib::Config.environment_const(key)
       end
 
+      def client(name)
+        Thread.current['clients_manager'].client(name)
+      end
+
+      def session
+        client('Website').session
+      end
+
     end
   end
 end

data/lib/test_logging.rb

@@ -36,10 +36,10 @@ module Moto
               end
             end
           end
-          @context.test.logger.debug("ENTER >>> #{self.class.name}::#{__callee__}(#{args})") unless skip_logging
+          Thread.current['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.test.logger.debug("LEAVE <<< #{self.class.name}::#{__callee__} => #{[result].to_s[1..-2]}") unless skip_logging
+          Thread.current['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.61'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.61
+  version: 0.7.0
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-18 00:00:00.000000000 Z
+date: 2016-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -87,6 +87,7 @@ files:
 - lib/app_generator.rb
 - lib/cli.rb
 - lib/clients/base.rb
+- lib/clients/clients_manager.rb
 - lib/clients/website.rb
 - lib/config.rb
 - lib/empty_listener.rb
@@ -94,7 +95,6 @@ files:
 - lib/exceptions/test_forced_failure.rb
 - lib/exceptions/test_forced_passed.rb
 - lib/exceptions/test_skipped.rb
-- lib/forward_context_methods.rb
 - lib/initializer.rb
 - lib/page.rb
 - lib/parser.rb

data/lib/forward_context_methods.rb

@@ -1,19 +0,0 @@
-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
-
-      # Access currently executed test
-      def test
-        @context.test
-      end
-   
-  end
-end