moto 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c94bb7f2fefa17c428807553a10595ef68cfcfc4
-  data.tar.gz: 480a4a33b77799351417effaa2d8fbe9f41bb4e7
+  metadata.gz: 5d372116a3d958f4b63271540b60d41d035f270e
+  data.tar.gz: c9aa807fd63cae0abe92f9103c1c44ea4f431235
 SHA512:
-  metadata.gz: f3aff69430e58ab6b5b4b175316e8dff36d1c84d0dc320fdc4fe9f0574a54245bd3a4121bc8aad8c017f6378acff6379de2d746f90fc6814b100d0e85d68b057
-  data.tar.gz: 52d57ac54c25c563e40dc7fe316772055e3c9709ef571ccb1c624e9c219ff7e25aad7dc59468a912c1952c121cb6f28a4f7ddcbea87f55b4db3f41b46289c1a0
+  metadata.gz: 274cc49288e9aaf523e23c64b9fd572d127c469f45213d234039e4fefc4cec598d97755e3208caea948cd2f24975b75dc74f857c18ae43f853b10422cd64eb1d
+  data.tar.gz: e101a87b1351073c09ac40cefc1fe76613a94783d25db13f2b4494c18756acce963d98f5639a429e2d684f83ce1139c0f81197958589e5b4b15bab75ad9c1a5a

data/lib/cli.rb

@@ -1,105 +1,105 @@
-# TODO: fix this dumb verification of current working directory
-unless File.exists? "#{Dir.pwd}/config/moto.rb"
-  puts 'Config file (config/moto.rb) not present.'
-  puts 'Does current working directory contain Moto application?'
-  exit 1
-end
-
-require 'logger'
-require 'pp'
-require 'yaml'
-require 'active_support/inflector'
-require 'active_support/core_ext/object/blank'
-
-require 'bundler/setup'
-Bundler.require
-
-module MotoApp
-  DIR = Dir.pwd
-end
-
-module Moto
-  DIR = File.dirname(File.dirname(__FILE__))
-end
-
-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 './result'
-require_relative './assert'
-require_relative './test'
-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 './listeners/webui'
-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_paths_absolute = []
-      test_classes = []
-
-      unless argv[ :tests ].nil?
-        argv[ :tests ].each do |dir_name|
-          test_paths = Dir.glob("#{MotoApp::DIR}/tests/#{dir_name}/**/*.rb")
-          test_paths -= test_paths_absolute
-          test_paths_absolute += test_paths
-        end
-      end
-
-      # TODO Optimization for files without #MOTO_TAGS
-      unless argv[ :tags ].nil?
-        tests_total = Dir.glob("#{MotoApp::DIR}/tests/**/*.rb")
-        argv[ :tags ].each do |tag_name|
-          tests_total.each do |test_dir|
-            test_body = File.read(test_dir)
-            test_body.each_line do |line|
-              line = line.delete(' ')
-              if line.include?( '#MOTO_TAGS')
-                if line.include?(tag_name + ',')
-                  test_paths_absolute.include?(test_dir) || test_paths_absolute << test_dir
-                  break
-                else
-                  break
-                end
-              end
-            end
-          end
-        end
-      end
-
-      #TODO Display criteria used
-      if test_paths_absolute.empty?
-        puts 'No tests found for given arguments'
-        exit 1
-      end
-
-      tg = TestGenerator.new(MotoApp::DIR)
-      test_paths_absolute.each do |test_path|
-        test_classes << tg.generate(test_path)
-      end
-
-      listeners = []
-      argv[ :reporters ].each do |r|
-        listener = 'Moto::Listeners::' + r.camelize
-        listeners << listener.constantize
-      end
-      
-      runner = Moto::Runner.new(test_classes, listeners, argv[:environments], argv[:config], argv[:name])
-      runner.run
-    end
-  
-  end
-end
+# TODO: fix this dumb verification of current working directory
+unless File.exists? "#{Dir.pwd}/config/moto.rb"
+  puts 'Config file (config/moto.rb) not present.'
+  puts 'Does current working directory contain Moto application?'
+  exit 1
+end
+
+require 'logger'
+require 'pp'
+require 'yaml'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/blank'
+
+require 'bundler/setup'
+Bundler.require
+
+module MotoApp
+  DIR = Dir.pwd
+end
+
+module Moto
+  DIR = File.dirname(File.dirname(__FILE__))
+end
+
+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 './result'
+require_relative './assert'
+require_relative './test'
+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 './listeners/webui'
+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_paths_absolute = []
+      test_classes = []
+
+      unless argv[ :tests ].nil?
+        argv[ :tests ].each do |dir_name|
+          test_paths = Dir.glob("#{MotoApp::DIR}/tests/#{dir_name}/**/*.rb")
+          test_paths -= test_paths_absolute
+          test_paths_absolute += test_paths
+        end
+      end
+
+      # TODO Optimization for files without #MOTO_TAGS
+      unless argv[ :tags ].nil?
+        tests_total = Dir.glob("#{MotoApp::DIR}/tests/**/*.rb")
+        argv[ :tags ].each do |tag_name|
+          tests_total.each do |test_dir|
+            test_body = File.read(test_dir)
+            test_body.each_line do |line|
+              line = line.delete(' ')
+              if line.include?( '#MOTO_TAGS')
+                if line.include?(tag_name + ',')
+                  test_paths_absolute.include?(test_dir) || test_paths_absolute << test_dir
+                  break
+                else
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+
+      #TODO Display criteria used
+      if test_paths_absolute.empty?
+        puts 'No tests found for given arguments'
+        exit 1
+      end
+
+      tg = TestGenerator.new(MotoApp::DIR)
+      test_paths_absolute.each do |test_path|
+        test_classes << tg.generate(test_path)
+      end
+
+      listeners = []
+      argv[ :reporters ].each do |r|
+        listener = 'Moto::Listeners::' + r.camelize
+        listeners << listener.constantize
+      end
+      
+      runner = Moto::Runner.new(test_classes, listeners, argv[:environments], argv[:config], argv[:name])
+      runner.run
+    end
+  
+  end
+end

data/lib/clients/website.rb

@@ -1,47 +1,49 @@
-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
+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
+        context.runner.my_config[:capybara][:default_selector] &&
+            Capybara.default_selector = context.runner.my_config[:capybara][:default_selector]
+        @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/listeners/webui.rb

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

data/lib/runner.rb

@@ -1,73 +1,73 @@
-module Moto
-  class Runner
-    
-    attr_reader :result
-    attr_reader :listeners
-    attr_reader :logger
-    attr_reader :environments
-    attr_reader :assert
-    attr_reader :config
-    attr_reader :name
-    
-    def initialize(tests, listeners, environments, config, name)
-      @tests = tests
-      @config = config
-      @threads = []
-      @name = name
-      
-      # 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
-      
-      @result = Result.new(self)
-      
-      # TODO: validate envs, maybe no-env should be supported as well?
-      environments << :__default if environments.empty?
-      @environments = environments
-      
-      @listeners = []
-      if listeners.empty?
-        my_config[:default_listeners].each do |l|
-          @listeners << l.new(self)
-        end
-      else
-        listeners.each do |l|
-          @listeners << l.new(self)
-        end
-      end
-      @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
-
-    # TODO: assigning tests to threads dynamically
-    def run
-      @listeners.each { |l| l.start_run }
-      test_slices = @tests.each_slice((@tests.size.to_f/my_config[:thread_count]).ceil).to_a
-      test_slices.each do |slice|
-        @threads << Thread.new do
-          tc = ThreadContext.new(self, slice)
-          tc.run
-        end
-      end
-      @threads.each{ |t| t.join }
-      @listeners.each { |l| l.end_run }
-    end
-    
-  end
+module Moto
+  class Runner
+    
+    attr_reader :result
+    attr_reader :listeners
+    attr_reader :logger
+    attr_reader :environments
+    attr_reader :assert
+    attr_reader :config
+    attr_reader :name
+    
+    def initialize(tests, listeners, environments, config, name)
+      @tests = tests
+      @config = config
+      @threads = []
+      @name = name
+      
+      # 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
+      
+      @result = Result.new(self)
+      
+      # TODO: validate envs, maybe no-env should be supported as well?
+      environments << :__default if environments.empty?
+      @environments = environments
+      
+      @listeners = []
+      if listeners.empty?
+        my_config[:default_listeners].each do |l|
+          @listeners << l.new(self)
+        end
+      else
+        listeners.each do |l|
+          @listeners << l.new(self)
+        end
+      end
+      @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
+
+    # TODO: assigning tests to threads dynamically
+    def run
+      @listeners.each { |l| l.start_run }
+      test_slices = @tests.each_slice((@tests.size.to_f/my_config[:thread_count]).ceil).to_a
+      test_slices.each do |slice|
+        @threads << Thread.new do
+          tc = ThreadContext.new(self, slice)
+          tc.run
+        end
+      end
+      @threads.each{ |t| t.join }
+      @listeners.each { |l| l.end_run }
+    end
+    
+  end
 end

data/lib/test.rb

@@ -1,102 +1,102 @@
-module Moto
-  class Test
-    
-    include Moto::Assert
-    include Moto::ForwardContextMethods
-    
-    attr_writer :context
-    attr_accessor :result
-    attr_reader :name
-    attr_reader :env
-    attr_reader :params
-    attr_writer :static_path
-    attr_accessor :log_path
-
-    class << self
-      attr_accessor :_path
-    end
-    
-    def self.inherited(k)
-      k._path = caller.first.match( /(.+):\d+:in/ )[1]
-    end
-    
-    def path
-      self.class._path
-    end
-    
-    def initialize
-      # @context = context
-      @result = Moto::Result::PENDING
-    end
-
-    def init(env, params, params_index)
-      @env = env
-      @params = params
-      set_name(params_index)
-    end
-
-    def set_name(params_index)
-      if @env == :__default 
-        return @name = "#{self.class.to_s}" if @params.empty?
-        return @name = "#{self.class.to_s}/#{@params['__name']}" if @params.key?('__name')
-        return @name = "#{self.class.to_s}/params_#{params_index}" unless @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')
-        return @name = "#{self.class.to_s}/#{@env}/params_#{params_index}" unless @params.key?('__name')
-      end
-      @name = self.class.to_s
-    end
-
-    def dir
-      # puts self.class.path
-      return File.dirname(@static_path) unless @static_path.nil?
-      File.dirname(self.path)
-    end
-    
-    def filename
-      return File.basename(@static_path, ".*") unless @static_path.nil?
-      File.basename(path, ".*")
-    end
- 
-    def run
-      # abstract
-    end
-
-    def before
-      # abstract
-    end
-
-    def after
-      # abstract
-    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
+module Moto
+  class Test
+    
+    include Moto::Assert
+    include Moto::ForwardContextMethods
+    
+    attr_writer :context
+    attr_accessor :result
+    attr_reader :name
+    attr_reader :env
+    attr_reader :params
+    attr_writer :static_path
+    attr_accessor :log_path
+
+    class << self
+      attr_accessor :_path
+    end
+    
+    def self.inherited(k)
+      k._path = caller.first.match( /(.+):\d+:in/ )[1]
+    end
+    
+    def path
+      self.class._path
+    end
+    
+    def initialize
+      # @context = context
+      @result = Moto::Result::PENDING
+    end
+
+    def init(env, params, params_index)
+      @env = env
+      @params = params
+      set_name(params_index)
+    end
+
+    def set_name(params_index)
+      if @env == :__default 
+        return @name = "#{self.class.to_s}" if @params.empty?
+        return @name = "#{self.class.to_s}/#{@params['__name']}" if @params.key?('__name')
+        return @name = "#{self.class.to_s}/params_#{params_index}" unless @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')
+        return @name = "#{self.class.to_s}/#{@env}/params_#{params_index}" unless @params.key?('__name')
+      end
+      @name = self.class.to_s
+    end
+
+    def dir
+      # puts self.class.path
+      return File.dirname(@static_path) unless @static_path.nil?
+      File.dirname(self.path)
+    end
+    
+    def filename
+      return File.basename(@static_path, ".*") unless @static_path.nil?
+      File.basename(path, ".*")
+    end
+ 
+    def run
+      # abstract
+    end
+
+    def before
+      # abstract
+    end
+
+    def after
+      # abstract
+    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

@@ -1,69 +1,69 @@
-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)
-      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
-      return m if next_modules.empty?
-      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"
-
-      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..-1].join('/')
-        
-        require "#{MotoApp::DIR}/lib/#{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
-    end
-    
-  end
+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)
+      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
+      return m if next_modules.empty?
+      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"
+
+      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..-1].join('/')
+        
+        require "#{MotoApp::DIR}/lib/#{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
+    end
+    
+  end
 end

data/lib/thread_context.rb

@@ -1,129 +1,132 @@
-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 :log_path
-    attr_reader :current_test
-    
-    def initialize(runner, tests)
-      @runner = runner
-      @tests = tests
-      @clients = {}
-      @tests.each do |t|
-        t.context = self
-      end
-      @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::Clients::' + name
-      name_moto = 'Moto::Clients::' + name
-      
-      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")
-      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..20].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
-      @tests.each do |test|
-        # remove log files from previous execution
-        Dir.glob("#{test.dir}/*.log").each {|f| File.delete f }
-        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) 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_with_index do |params, params_index|
-            # TODO: add filtering out params that are specific to certain envs
-            (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('/', '_')}.log"
-              @logger = Logger.new(File.open(test.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) }
-              # 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
-            end # RETRY
-          end
-        end
-      end
-      @clients.each_value { |c| c.end_run }
-    end
-  
-  end
+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 :log_path
+    attr_reader :current_test
+    
+    def initialize(runner, tests)
+      @runner = runner
+      @tests = tests
+      @clients = {}
+      @tests.each do |t|
+        t.context = self
+      end
+      @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::Clients::' + name
+      name_moto = 'Moto::Clients::' + name
+      
+      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")
+      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..20].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
+      @tests.each do |test|
+        # remove log files from previous execution
+        Dir.glob("#{test.dir}/*.log").each {|f| File.delete f }
+        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(ERB.new(File.read(params_path)).result) 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_with_index do |params, params_index|
+            # TODO: add filtering out params that are specific to certain envs
+            (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('/', '_')}.log"
+              @logger = Logger.new(File.open(test.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) }
+              # 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
+            end # RETRY
+          end
+        end
+      end
+      @clients.each_value { |c| c.end_run }
+    end
+  
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-18 00:00:00.000000000 Z
+date: 2015-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -125,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.15
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: Moto - yet another web testing framework