moto 0.0.31 → 0.0.32

data/lib/test_generator.rb

@@ -54,27 +54,24 @@ module Moto
       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 will be instantized with raise injected into its run()
+      # 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
+        class_name = Moto::Test::Base
         test_object = class_name.new
 
         class << test_object
           attr_accessor :custom_name
-        end
-
-        test_object.custom_name = test_path_absolute.gsub("#{MotoApp::DIR}/",'moto_app/').camelize.chomp('.rb')
 
-        class << test_object
           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
@@ -83,7 +80,7 @@ module Moto
     end
 
     def generate_for_run_body(test_path_absolute, method_body)
-      base = Moto::Test
+      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

data/lib/thread_context.rb

@@ -6,14 +6,15 @@ module Moto
     # all resources specific for single thread will be initialized here. E.g. browser session
     attr_reader :runner
     attr_reader :logger
-    # attr_reader :log_path
     attr_reader :current_test
 
-    def initialize(runner, 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
 
@@ -65,10 +66,10 @@ module Moto
       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
+               "@config#{key.split('.').map { |a| "['#{a}']" }.join('')}"
+             else
+               "@config['#{key}']"
+             end
       begin
         v = eval code
         raise if v.nil?
@@ -80,59 +81,77 @@ module Moto
 
     def run
       # remove log/screenshot files from previous execution
-      Dir.glob("#{@test.dir}/*.{log,png}").each {|f| File.delete f }
+      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 = [{}]
 
-        # YAML config files
-        #params_path = "#{@test.dir}/#{@test.filename}_params.yml"
-        #params_all = YAML.load(ERB.new(File.read(params_path)).result) if File.exists?(params_path)
-
         # 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'] 
+            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"
+          # 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|
-            @test.init(env, params, params_index)
-            # TODO: log path might be specified (to some extent) by the configuration
-            #@test.log_path = "#{@test.dir}/#{@test.name.gsub(/\s+/, '_').gsub(':', '_').gsub('::', '_').gsub('/', '_')}.log"
-            @test.log_path = "#{@test.dir}/#{@test.name.demodulize.gsub('/', '_')}.log"
-            @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
-            @runner.listeners.each { |l| l.start_test(@test) }
+
+            # 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
-            rescue Exceptions::TestForcedPassed, Exceptions::TestForcedFailure, Exceptions::TestSkipped => e
-              logger.info(e.message)
-              @runner.result.add_error(@test, e)
+              @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) }
-              @runner.result.add_error(@test, e)
             end
+
             @test.after
             @clients.each_value { |c| c.end_test(@test) }
-            # HAX: running end_test on results now, on other listeners after logger is closed
-            @runner.listeners.first.end_test(@test)
-            @logger.info("Result: #{@test.result}")
-            @logger.close
-            @runner.listeners[1..-1].each { |l| l.end_test(@test) }
-            break unless [Result::FAILURE, Result::ERROR].include? @test.result
-            sleep sleep_time unless attempt.equal? max_attempts
-          end # RETRY
+
+            @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 }

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Moto
-  VERSION = '0.0.31'
+  VERSION = '0.0.32'
 end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.31
+  version: 0.0.32
 platform: ruby
 authors:
 - Bartek Wilczek
 - Maciej Stark
 - Radosław Sporny
+- Michał Kujawski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-21 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -76,6 +77,7 @@ email:
 - bwilczek@gmail.com
 - stark.maciej@gmail.com
 - r.sporny@gmail.com
+- michal.kujawski@gmail.com
 executables:
 - moto
 extensions: []
@@ -83,7 +85,6 @@ extra_rdoc_files: []
 files:
 - bin/moto
 - lib/app_generator.rb
-- lib/assert.rb
 - lib/cli.rb
 - lib/clients/base.rb
 - lib/clients/website.rb
@@ -94,17 +95,20 @@ files:
 - lib/exceptions/test_skipped.rb
 - lib/forward_context_methods.rb
 - lib/initializer.rb
-- lib/listeners/base.rb
-- lib/listeners/console.rb
-- lib/listeners/console_dots.rb
-- lib/listeners/junit_xml.rb
-- lib/listeners/webui.rb
 - lib/page.rb
 - lib/parser.rb
-- lib/result.rb
+- lib/reporting/listeners/base.rb
+- lib/reporting/listeners/console.rb
+- lib/reporting/listeners/console_dots.rb
+- lib/reporting/listeners/junit_xml.rb
+- lib/reporting/listeners/webui.rb
+- lib/reporting/run_status.rb
+- lib/reporting/test_reporter.rb
 - lib/runner.rb
 - lib/runner_logging.rb
-- lib/test.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

data/lib/assert.rb

@@ -1,32 +0,0 @@
-module Moto
-  module Assert
-
-    def assert_equal(a, b)
-      assert(a==b, "Arguments should be equal: #{a} != #{b}.")
-    end
-
-    def assert_true(b)
-      assert(b, "Logical condition not met, expecting true, given false.")
-    end
-
-    def assert_false(b)
-      assert(!b, "Logical condition not met, expecting false, given true.")
-    end
-
-    def assert(condition, message)
-      unless condition
-        
-        line_number = if @context.current_test.evaled 
-          caller.select{ |l| l.match(/\(eval\):\d*:in `run'/) }.first[/\d+/].to_i - 1 # -1 because of added method header in generated class
-        else
-          line_number = caller.select{ |l| l.match(/#{@context.current_test.static_path}:\d*:in `run'/) }.first[/\d+/].to_i - 1
-        end
-
-        full_message = "ASSERTION FAILED in line #{line_number}: #{message}"
-        @context.runner.result.add_failure(self, full_message)
-        logger.error(full_message)
-      end
-    end
-
-  end
-end

data/lib/listeners/base.rb

@@ -1,26 +0,0 @@
-module Moto
-  module Listeners
-    class Base
-      
-      def initialize(runner)
-        @runner=runner
-      end
-      
-      def start_run
-        # abstract
-      end
-      
-      def end_run
-        # abstract
-      end
-      
-      def start_test(test)
-        # abstract
-      end
-  
-      def end_test(test)
-        # abstract
-      end      
-    end
-  end
-end

data/lib/listeners/console.rb

@@ -1,29 +0,0 @@
-module Moto
-  module Listeners
-    class Console < Base
-
-      def start_run
-        puts "START"
-      end
-      
-      def end_run
-        puts ""
-        puts "FINISHED: #{@runner.result.summary[:result]}, duration: #{Time.at(@runner.result.summary[:duration]).utc.strftime("%H:%M:%S")}"
-        puts "Tests executed: #{@runner.result.summary[:cnt_all]}"
-        puts "  Passed:       #{@runner.result.summary[:cnt_passed]}"
-        puts "  Failure:      #{@runner.result.summary[:cnt_failure]}"
-        puts "  Error:        #{@runner.result.summary[:cnt_error]}"
-        puts "  Skipped:      #{@runner.result.summary[:cnt_skipped]}"
-      end
-
-      def start_test(test)
-        print test.name
-      end
-  
-      def end_test(test)
-        puts "\t#{@runner.result[test.name][:result]}"
-      end
-
-    end
-  end
-end

data/lib/listeners/console_dots.rb

@@ -1,63 +0,0 @@
-module Moto
-  module Listeners
-    class ConsoleDots < Base
-
-      def start_run
-      end
-      
-      def end_run
-        puts ""
-        puts ""
-        puts "FINISHED: #{@runner.result.summary[:result]}, duration: #{Time.at(@runner.result.summary[:duration]).utc.strftime("%H:%M:%S")}"
-        puts "Tests executed: #{@runner.result.summary[:cnt_all]}"
-        puts "  Passed:       #{@runner.result.summary[:cnt_passed]}"
-        puts "  Failure:      #{@runner.result.summary[:cnt_failure]}"
-        puts "  Error:        #{@runner.result.summary[:cnt_error]}"
-        puts "  Skipped:      #{@runner.result.summary[:cnt_skipped]}"
-        
-        if @runner.result.summary[:cnt_failure] > 0
-          puts ""
-          puts "FAILURES: " 
-          @runner.result.summary[:tests_failure].each do |test_name, data|
-            puts test_name
-            puts "\t#{data[:failures].join("\n\t")}"
-            puts ""
-          end
-        end
-        
-        if @runner.result.summary[:cnt_error] > 0
-          puts ""
-          puts "ERRORS: " 
-          @runner.result.summary[:tests_error].each do |test_name, data|
-            puts test_name
-            puts "\t#{data[:error]}"
-            puts ""
-          end
-        end
-        
-        if @runner.result.summary[:cnt_skipped] > 0
-          puts ""
-          puts "SKIPPED: " 
-          @runner.result.summary[:tests_skipped].each do |test_name, data|
-            puts test_name
-            puts "\t#{data[:error]}"
-            puts ""
-          end
-        end
-      end
-
-      def start_test(test)
-      end
-  
-      def end_test(test)
-        print case @runner.result[test.name][:result]
-        when :passed then "."
-        when :failure then "F"
-        when :error then "E"
-        when :skipped then "s"
-        end 
-      end
-
-    end
-  end
-end

data/lib/listeners/junit_xml.rb

@@ -1,37 +0,0 @@
-require 'nokogiri'
-
-module Moto
-  module Listeners
-    class JunitXml < Base
-
-      def end_run
-        path = @runner.my_config[:output_file]
-
-        builder = Nokogiri::XML::Builder.new { |xml|
-          xml.testsuite(
-                errors: @runner.result.summary[:cnt_error], 
-                failures: @runner.result.summary[:cnt_failure], 
-                name: "Moto run", 
-                tests: @runner.result.summary[:cnt_all], 
-                time: @runner.result.summary[:duration], 
-                timestamp: Time.at(@runner.result.summary[:started_at])) do
-            @runner.result.all.each do |test_name, data|
-              xml.testcase(name: test_name, time: data[:duration], classname: data[:class].name, moto_result: data[:result]) do
-                if !data[:error].nil?
-                  xml.error(message: data[:error].message)
-                elsif data[:failures].count > 0
-                  data[:failures].each do |f|
-                    xml.failure(message: f)
-                  end
-                end
-              end
-            end
-          end
-        }
-
-        File.open(path, 'w') {|f| f.write(builder.to_xml) }        
-      end
-
-    end
-  end
-end

data/lib/listeners/webui.rb

@@ -1,71 +0,0 @@
-require 'rest-client'
-require 'sys/uname'
-
-module Moto
-  module Listeners
-    class Webui < Base
-
-      def start_run
-        # POST http://sandbox.dev:3000/api/runs/create
-        @url = @runner.my_config[:url]
-        data = {
-          name:  @runner.name,
-          result: Moto::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
-        }
-        @run = JSON.parse( RestClient.post( "#{@url}/api/runs", data.to_json, :content_type => :json, :accept => :json ) )
-        @tests = {}
-      end
-      
-      def end_run
-        # PUT http://sandbox.dev:3000/api/runs/1
-        data = {
-          result: @runner.result.summary[:result],
-          cnt_all: @runner.result.summary[:cnt_all],
-          cnt_passed: @runner.result.summary[:cnt_passed],
-          cnt_failure: @runner.result.summary[:cnt_failure],
-          cnt_error: @runner.result.summary[:cnt_error],
-          cnt_skipped: @runner.result.summary[:cnt_skipped],
-          duration: @runner.result.summary[:duration]
-        }
-        @run = JSON.parse( RestClient.put( "#{@url}/api/runs/#{@run['id']}", data.to_json, :content_type => :json, :accept => :json ) )
-      end
-
-      def start_test(test)
-        # POST http://sandbox.dev:3000/api/tests/create
-        data = {
-          name:  test.name,
-          class_name: test.class.name,
-          log: nil,
-          run_id: @run['id'],
-          env: test.env,
-          parameters: test.params.to_s,
-          result: Moto::Result::RUNNING,
-          error: nil,
-          failures: nil,
-        }
-        @tests[test.name] = JSON.parse( RestClient.post( "#{@url}/api/tests", data.to_json, :content_type => :json, :accept => :json ) )        
-      end
-
-      def end_test(test)
-        log = File.read(test.log_path)
-        data = {
-          log: log,
-          result: @runner.result[test.name][:result],
-          error: @runner.result[test.name][:error].nil? ? nil : @runner.result[test.name][:error].message,
-          failures: @runner.result[test.name][:failures].join("\n\t"),
-          duration: @runner.result[test.name][:duration]
-        }
-        @tests[test.name] = JSON.parse( RestClient.put( "#{@url}/api/tests/#{@tests[test.name]['id']}", data.to_json, :content_type => :json, :accept => :json ) )
-      end
-
-    end
-  end
-end