moto 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9148f21a0e6aa5b6a157f4430be6e4669c8ebb5f
-  data.tar.gz: 493eceb7d79389aace5dfb095167ec1639024505
+  metadata.gz: 1c00f9d85d66a288aab3de0089ccb7cd20568dcf
+  data.tar.gz: 913cef9df55570bdcbb9c7e4570ce7a36ab6a6aa
 SHA512:
-  metadata.gz: 59ed4b2f7ce51f3c1480673de389ff26ca961502474253cca32de6189f0d2fe7404dc937331ede52bfb0c185296ef4fa5bf5c2255502b7d9a58f0283b97aa39c
-  data.tar.gz: 802ff8c1cef394da74787ea43433ce46f213ab67b48a5abefce6c3a5c48dad7acf846e0292363ba7390bae72c40f2c7f4ae4dd4d5045ac1033eb17973f3fffc2
+  metadata.gz: 65932f837806445c3f132b5b01228328f061d63a3247685f3ac5000fed0a6396135a2a92673bc5aa177a8e74fcbf1c5fd00463bb2102cb71c6c52fe7d3d7a7cb
+  data.tar.gz: d3bb6d1cf7b48bde43e8c8729aeae70666ec1a53e0208399ec7662ce6b564547bb6c11a863fb1d069a18dfe17d3aac797d636fa5499e6370b0e8b4906170158a

data/bin/moto

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/cli'
+require_relative '../lib/parser'
 
-Moto::Cli.run ARGV
+Moto::Parser.run ARGV

data/lib/app_generator.rb

@@ -0,0 +1,9 @@
+module Moto
+  class AppGenerator
+    
+    def self.run(argv)
+      
+    end
+    
+  end
+end

data/lib/assert.rb

@@ -2,13 +2,19 @@ module Moto
   module Assert
 
     def assert_equal(a, b)
-      assert(a==b, "Arguments should be 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(condition, message)
       unless condition
-        @context.runner.result.add_failure(self, message)
-        logger.error("ASSERTION FAILED: #{message}")
+        line_number = caller.select{ |l| l.match(/\(eval\):\d*:in `run'/) }.first[/\d+/].to_i - 1 # -1 because of added method header in generated class
+        full_message = "ASSERTION FAILED in line #{line_number}: #{message}"
+        @context.runner.result.add_failure(self, full_message)
+        logger.error(full_message)
       end
     end
 

data/lib/cli.rb

@@ -10,12 +10,18 @@ require 'pp'
 require 'yaml'
 require 'active_support/inflector'
 require 'active_support/core_ext/object/blank'
+require 'fileutils'
 
 require 'bundler/setup'
 Bundler.require
 
-APP_DIR = Dir.pwd
-MOTO_DIR = File.dirname(File.dirname(__FILE__))
+module MotoApp
+  DIR = Dir.pwd
+end
+
+module Moto
+  DIR = File.dirname(File.dirname(__FILE__))
+end
 
 require_relative './empty_listener'
 require_relative './test_logging'
@@ -29,33 +35,29 @@ require_relative './page'
 require_relative './clients/base'
 require_relative './listeners/base'
 require_relative './listeners/console'
+require_relative './listeners/console_dots'
+require_relative './listeners/junit_xml'
 require_relative './test_generator'
+require_relative './exceptions/moto'
+require_relative './exceptions/test_skipped'
+require_relative './exceptions/test_forced_failure'
+require_relative './exceptions/test_forced_passed'
 
 module Moto
 
   class Cli
   
     def self.run(argv)
-      test_class_name = argv[0]
-      
-      tg = TestGenerator.new(APP_DIR)
-      t = tg.generate(test_class_name)
-      
-      tests = [t]
-      
-      # parsing ARGV and creating config will come here
-      # instantiation of tests for ARGV params also happens here
-      # instantiate listeners/reporters
-      
-      # listeners = []
-      listeners = [Moto::Listeners::Console]
-      environments = [:qa, :qa2]
-      # handle possible syntax error here
-      config = eval(File.read("#{APP_DIR}/config/moto.rb"))
-      # overwrite config with values from ARGV (if any given)
-      # e.g. config[:capybara][:default_driver] = :selenium
-      
-      runner = Moto::Runner.new(tests, listeners, environments, config)
+      tests = []
+        argv[ :tests ].each do |test_name|
+        test_class_name = test_name
+              
+        tg = TestGenerator.new(MotoApp::DIR)
+        t = tg.generate(test_class_name)      
+        tests << t
+      end
+     
+      runner = Moto::Runner.new(tests, argv[ :reporters ], argv[ :environments ], argv[ :config ])
       runner.run
     end
   

data/lib/clients/website.rb

@@ -1,47 +1,47 @@
-require 'capybara'
-
-module Moto
-  module Clients
-	
-  	class Website < Moto::Clients::Base
-
-      attr_reader :session
-      
-      ignore_logging(:page)
-      ignore_logging(:context)
-      ignore_logging(:session)
-  		 		
-      def start_run
-        # TODO: make session driver configurable
-        @session = Capybara::Session.new(context.runner.config[:capybara][:default_driver])
-        @pages = {}
-      end
-      
-      def end_run
-        @session.driver.browser.close # TODO: check that it really works
-      end
-      
-      def start_test(test)
-        # @context.current_test.logger.info("Hi mom, I'm opening some pages!")
-        @session.reset_session!
-      end
-  
-      def end_test(test)
-        @session.reset_session!
-      end   
-  		
-  		def page(p)
-  		  page_class_name = "#{self.class.name}Pages::#{p}"
-  		  page_class_name.gsub!('Moto::', 'MotoApp::')
-  		  if @pages[page_class_name].nil?
-          a = page_class_name.underscore.split('/')
-          page_path = a[1..20].join('/')
-          require "#{APP_DIR}/#{page_path}"	    
-  		    @pages[page_class_name] = page_class_name.constantize.new(self)
-  		  end
-  		  @pages[page_class_name]
-  		end
-  		
-  	end
-  end
-end
+require 'capybara'
+
+module Moto
+  module Clients
+	
+  	class Website < Moto::Clients::Base
+
+      attr_reader :session
+      
+      ignore_logging(:page)
+      ignore_logging(:context)
+      ignore_logging(:session)
+  		 		
+      def start_run
+        # TODO: make session driver configurable
+        @session = Capybara::Session.new(context.runner.my_config[:capybara][:default_driver])
+        @pages = {}
+      end
+      
+      def end_run
+        @session.driver.browser.close # TODO: check that it really works
+      end
+      
+      def start_test(test)
+        # @context.current_test.logger.info("Hi mom, I'm opening some pages!")
+        @session.reset_session!
+      end
+  
+      def end_test(test)
+        @session.reset_session!
+      end   
+  		
+  		def page(p)
+  		  page_class_name = "#{self.class.name}Pages::#{p}"
+  		  page_class_name.gsub!('Moto::', 'MotoApp::')
+  		  if @pages[page_class_name].nil?
+          a = page_class_name.underscore.split('/')
+          page_path = a[1..20].join('/')
+          require "#{MotoApp::DIR}/lib/#{page_path}"	    
+  		    @pages[page_class_name] = page_class_name.constantize.new(self)
+  		  end
+  		  @pages[page_class_name]
+  		end
+  		
+  	end
+  end
+end

data/lib/exceptions/moto.rb

@@ -0,0 +1,7 @@
+module Moto
+  module Exceptions
+    class MotoException < RuntimeError
+      
+    end
+  end
+end

data/lib/exceptions/test_forced_failure.rb

@@ -0,0 +1,7 @@
+module Moto
+  module Exceptions
+    class TestForcedFailure  < MotoException
+      
+    end
+  end
+end

data/lib/exceptions/test_forced_passed.rb

@@ -0,0 +1,7 @@
+module Moto
+  module Exceptions
+    class TestForcedPassed  < MotoException
+      
+    end
+  end
+end

data/lib/exceptions/test_skipped.rb

@@ -0,0 +1,7 @@
+module Moto
+  module Exceptions
+    class TestSkipped  < MotoException
+      
+    end
+  end
+end

data/lib/listeners/console.rb

@@ -13,6 +13,7 @@ module Moto
         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)

data/lib/listeners/console_dots.rb

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,37 @@
+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/parser.rb

@@ -0,0 +1,61 @@
+require 'optparse'
+require 'yaml'
+
+require_relative '../lib/cli'
+require_relative '../lib/app_generator'
+
+module Moto
+
+  class Parser
+  
+    def self.run(argv)
+            
+      # TODO Generate app / Change the way parsing options goes so it doesnt generate them if they`re not needed
+      case argv[0]
+      when 'run' then Moto::Cli.run run_parse(argv)
+      when 'help' then show_help
+      when 'generate' then Moto::AppGenerator.run generate_parse(argv)
+      end
+    end
+    
+    def self.run_parse(argv)   
+      # puts Moto::DIR
+      # Default options 
+      options = {}
+      options[:reporters] = [Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml] 
+      options[:config] = eval(File.read("#{MotoApp::DIR}/config/moto.rb"))
+      options[:environments] = []
+         
+      # Parse arguments
+      # TODO eval ?
+      # TODO const 
+      # TODO reporters should be consts - not strings
+      OptionParser.new do |opts|       
+          opts.on('-t', "--tests Tests", Array) { |v| options[:tests ] = v }
+          opts.on('-r', '--reporters Reporters', Array) { |v| options[:reporters] = v }
+          opts.on('-e', '--environments Environment', Array) { |v| options[:environments] = v }
+          opts.on('-c', '--const Const') { |v| options[:const] = v }
+          opts.on('-cfg', '--config Config') { |v| options[:config] = options[:config].merge( eval( v ) ) }
+      end.parse!
+      return options
+    end
+    
+    def self.generate_parse(argv)
+      options = {}
+      options[:dir]
+    end
+    
+    def self.show_help
+      puts """
+      Moto CLI Help:
+      moto run:      
+       -t, --tests = Tests to be executed. For e.x Tests\Failure\Failure.rb should be passed as Tests::Failure
+       -r, --reporter = Reporters to be used. Defaults are Moto::Listeners::ConsoleDots, Moto::Listeners::JunitXml
+       -e, --environment etc etc
+      moto generate:
+      moto generate app_name -d, --dir = directory. Default is current dir.
+      """
+    end
+    
+  end
+end

data/lib/result.rb

@@ -6,6 +6,7 @@ module Moto
     PASSED = :passed # 0
     FAILURE = :failure # 1
     ERROR = :error # 2
+    SKIPPED = :skipped # 3
 
     attr_reader :summary
 
@@ -13,6 +14,10 @@ module Moto
       @results[key]
     end
     
+    def all
+      @results
+    end
+    
     def initialize(runner)
       @runner = runner
       @results = {}
@@ -32,9 +37,14 @@ module Moto
       @summary[:result] = FAILURE unless @results.values.select{ |v| v[:failures].count > 0 }.empty?
       @summary[:result] = ERROR unless @results.values.select{ |v| !v[:error].nil? }.empty?
       @summary[:cnt_all] = @results.count
-      @summary[:cnt_passed] = @results.values.select{ |v| v[:result] == PASSED }.count
-      @summary[:cnt_failure] = @results.values.select{ |v| v[:result] == FAILURE }.count
-      @summary[:cnt_error] = @results.values.select{ |v| v[:result] == ERROR }.count
+      @summary[:tests_passed] = @results.select{ |k,v| v[:result] == PASSED }
+      @summary[:tests_failure] = @results.select{ |k,v| v[:result] == FAILURE }
+      @summary[:tests_error] = @results.select{ |k,v| v[:result] == ERROR }
+      @summary[:tests_skipped] = @results.select{ |k,v| v[:result] == SKIPPED }
+      @summary[:cnt_passed] = @summary[:tests_passed].count
+      @summary[:cnt_failure] = @summary[:tests_failure].count
+      @summary[:cnt_error] = @summary[:tests_error].count
+      @summary[:cnt_skipped] = @summary[:tests_skipped].count
     end
     
     def start_test(test)
@@ -43,10 +53,21 @@ module Moto
 
     def end_test(test)
       # calculate result basing on errors/failures
+      @results[test.name][:finished_at] = Time.now.to_f
       test.result = PASSED
       test.result = FAILURE unless @results[test.name][:failures].empty?
-      test.result = ERROR unless @results[test.name][:error].nil?
-      @results[test.name][:finished_at] = Time.now.to_f
+      unless @results[test.name][:error].nil?
+        if @results[test.name][:error].is_a? Moto::Exceptions::TestSkipped
+          test.result = SKIPPED
+        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedPassed
+          test.result = PASSED
+        elsif @results[test.name][:error].is_a? Moto::Exceptions::TestForcedFailure
+          add_failure(test, @results[test.name][:error].message)
+          test.result = FAILURE
+        else
+          test.result = ERROR
+        end
+      end
       @results[test.name][:duration] = @results[test.name][:finished_at] - @results[test.name][:started_at]
       @results[test.name][:result] = test.result
     end

data/lib/runner.rb

@@ -15,12 +15,13 @@ module Moto
       
       # TODO: initialize logger from config (yml or just ruby code)
       # @logger = Logger.new(STDOUT)
-      @logger = Logger.new(File.open("#{APP_DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
+      @logger = Logger.new(File.open("#{MotoApp::DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
       # @logger.level = Logger::WARN
       
       @result = Result.new(self)
       
       # TODO: validate envs, maybe no-env should be supported as well?
+      environments << :__default if environments.empty?
       @environments = environments
       
       @listeners = []
@@ -30,9 +31,25 @@ module Moto
       @listeners.unshift(@result)
     end
     
+    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
       @listeners.each { |l| l.start_run }
-      test_slices = @tests.each_slice((@tests.size.to_f/@config[:thread_count]).ceil).to_a
+      test_slices = @tests.each_slice((@tests.size.to_f/my_config[:thread_count]).ceil).to_a
       (0...test_slices.count).each do |i|
         @threads << Thread.new do
           tc = ThreadContext.new(self, test_slices[i])

data/lib/test.rb

@@ -38,8 +38,13 @@ module Moto
     end
 
     def set_name
-      return @name = "#{self.class.to_s}/#{@env}" if @params.empty?
-      return @name = "#{self.class.to_s}/#{@env}/#{@params[:__name]}" if @params.key?(:__name)
+      if @env == :__default 
+        return @name = "#{self.class.to_s}" if @params.empty?
+        return @name = "#{self.class.to_s}/#{@params['__name']}" if @params.key?('__name')
+      else
+        return @name = "#{self.class.to_s}/#{@env}" if @params.empty?
+        return @name = "#{self.class.to_s}/#{@env}/#{@params['__name']}" if @params.key?('__name')
+      end
       @name = self.class.to_s
     end
 
@@ -73,6 +78,33 @@ module Moto
     def client(name)
       @context.client(name)
     end
+ 
+    def skip(msg = nil)
+      if msg.nil?
+        msg = "Test skipped with no reason given."
+      else
+        msg = "Skip reason: #{msg}"
+      end
+      raise Exceptions::TestSkipped.new msg
+    end
+
+    def fail(msg = nil)
+      if msg.nil?
+        msg = "Test forcibly failed with no reason given."
+      else
+        msg = "Forced failure, reason: #{msg}"
+      end
+      raise Exceptions::TestForcedFailure.new msg
+    end
+
+    def pass(msg = nil)
+      if msg.nil?
+        msg = "Test forcibly passed with no reason given."
+      else
+        msg = "Forced passed, reason: #{msg}"
+      end
+      raise Exceptions::TestForcedPassed.new msg
+    end
 
   end
 end

data/lib/test_generator.rb

@@ -17,7 +17,7 @@ module Moto
       test_path = (a[1..20]+[a[-1]]).join('/')
       
       # TODO: check if this path and constant exists
-      require "#{APP_DIR}/#{test_path}"
+      require "#{MotoApp::DIR}/#{test_path}"
       test_const = class_name.safe_constantize  
       test_const.new    
     end
@@ -39,17 +39,29 @@ module Moto
       full_class_name = 'MotoApp::Tests::'+class_name
       a = full_class_name.underscore.split('/')
       test_path = (a[1..20]+[a[-1]]).join('/')
-      test_path = "#{APP_DIR}/#{test_path}.rb"
+      test_path = "#{MotoApp::DIR}/#{test_path}.rb"
 
       method_body = File.read(test_path) + "\n"
 
+      base = Moto::Test
+      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..20].join('/')
+        
+        require "#{MotoApp::DIR}/lib/#{base_test_path}" 
+        base = base_class_string.constantize
+      end
+
       # MotoApp::Tests::Login::Short
       consts = full_class_name.split('::')
       class_name = consts.pop
 
       consts.shift 2 # remove Moto::Test as already defined
       m = create_module_tree(MotoApp::Tests, consts)
-      cls = Class.new(Moto::Test)
+      cls = Class.new(base)
       m.const_set(class_name.to_sym, cls)
       
       test_object = cls.new

data/lib/thread_context.rb

@@ -15,7 +15,7 @@ module Moto
         t.context = self
       end
       # TODO: add all *.yml files from that dir
-      @config = YAML.load_file("#{APP_DIR}/config/const.yml")
+      @config = YAML.load_file("#{MotoApp::DIR}/config/const.yml")
     end
     
     def client(name)
@@ -24,13 +24,13 @@ module Moto
       name_app = 'MotoApp::Clients::' + name
       name_moto = 'Moto::Clients::' + name
       
-      c = try_client(name_app, APP_DIR)
+      c = try_client(name_app, "#{MotoApp::DIR}/lib")
       unless c.nil?
         @clients[name] = c
         return c
       end
 
-      c = try_client(name_moto, "#{MOTO_DIR}/lib")
+      c = try_client(name_moto, "#{Moto::DIR}/lib")
       unless c.nil?
         @clients[name] = c
         return c
@@ -55,43 +55,64 @@ module Moto
     end
     
     def const(key)
-      # TODO: add support to consts with no env
-      @config[@current_test.env.to_s][key.to_s]
+      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
       @tests.each do |test|
+        # remove log files from previous execution
+        FileUtils.rm_rf Dir.glob("#{test.dir}/*.log")
+        max_attempts = @runner.my_config[:max_attempts] || 1
         @runner.environments.each do |env|
           params_path = "#{test.dir}/#{test.filename}.yml"
           params_all = [{}]
-          params_all = YAML.load_file(params_path).map{|h| Hash[ h.map{|k,v| [ k.to_sym, v ] } ] } if File.exists?(params_path)
-          # params_all = YAML.load_file(params_path) if File.exists?(params_path)
+          params_all = YAML.load_file(params_path) if File.exists?(params_path)
+          # or convert keys to symbols?
+          # params_all = YAML.load_file(params_path).map{|h| Hash[ h.map{|k,v| [ k.to_sym, v ] } ] } if File.exists?(params_path)
           params_all.each do |params|
             # TODO: add filtering out params that are specific to certain envs
-            test.init(env, params)
-            # TODO: log path might be specified (to some extent) by the configuration
-            @log_path = "#{test.dir}/#{test.name.gsub(/\s+/, '_').gsub('::', '_').gsub('/', '_')}.log"
-            # TODO: remove log files from previous execution
-            @logger = Logger.new(File.open(@log_path, File::WRONLY | File::TRUNC | File::CREAT))
-            # TODO: make logger level configurable
-            @logger.level = @runner.config[:log_level]
-            @current_test = test
-            @runner.listeners.each { |l| l.start_test(test) }
-            @clients.each_value { |c| c.start_test(test) }
-            test.before
-            @logger.info "Start: #{test.name}"
-            begin
-              test.run
-            rescue Exception => e  
-              @logger.error("#{e.class.name}: #{e.message}")  
-              @logger.error(e.backtrace.join("\n"))
-              @runner.result.add_error(test, e)
-            end 
-            test.after
-            @clients.each_value { |c| c.end_test(test) }
-            @runner.listeners.each { |l| l.end_test(test) }
-            @logger.info("Result: #{test.result}")
-            @logger.close
+            (1..max_attempts).each do |attempt|
+              test.init(env, params)
+              # TODO: log path might be specified (to some extent) by the configuration
+              @log_path = "#{test.dir}/#{test.name.gsub(/\s+/, '_').gsub('::', '_').gsub('/', '_')}.log"
+              @logger = Logger.new(File.open(@log_path, File::WRONLY | File::TRUNC | File::CREAT))
+              # TODO: make logger level configurable
+              @logger.level = @runner.my_config[:log_level]
+              @current_test = test
+              @runner.listeners.each { |l| l.start_test(test) }
+              @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)
+              rescue Exception => e  
+                @logger.error("#{e.class.name}: #{e.message}")  
+                @logger.error(e.backtrace.join("\n"))
+                @runner.result.add_error(test, e)
+              end 
+              test.after
+              @clients.each_value { |c| c.end_test(test) }
+              @runner.listeners.each { |l| l.end_test(test) }
+              @logger.info("Result: #{test.result}")
+              @logger.close
+              break unless [Result::FAILURE, Result::ERROR].include? test.result
+            end # RETRY
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-17 00:00:00.000000000 Z
+date: 2015-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,6 +25,34 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This is a development version of a rails philosophy inspired framework
   for web applications functional testing. It supports (or will support) threading,
   scenario parametrization, different test environments and much more. Stay tuned
@@ -37,10 +65,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/app_generator.rb
 - lib/assert.rb
 - lib/cli.rb
 - lib/empty_listener.rb
 - lib/page.rb
+- lib/parser.rb
 - lib/result.rb
 - lib/runner.rb
 - lib/runner_logging.rb
@@ -50,8 +80,14 @@ files:
 - lib/thread_context.rb
 - lib/clients/base.rb
 - lib/clients/website.rb
+- lib/exceptions/moto.rb
+- lib/exceptions/test_forced_failure.rb
+- lib/exceptions/test_forced_passed.rb
+- lib/exceptions/test_skipped.rb
 - lib/listeners/base.rb
 - lib/listeners/console.rb
+- lib/listeners/console_dots.rb
+- lib/listeners/junit_xml.rb
 - bin/moto
 homepage: https://github.com/bwilczek/moto
 licenses:
@@ -63,9 +99,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -73,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.15
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Moto - yet another web testing framework