moto 0.0.31 → 0.0.32

data/lib/reporting/test_reporter.rb

@@ -0,0 +1,83 @@
+require_relative 'run_status'
+
+module Moto
+  module Reporting
+
+    # Manages reporting test and run status' to attached listeners
+    class TestReporter
+      # @param [Array] listeners An array of strings, which represent qualified names of classes (listeners) that will be instantiated.
+      #                empty array is passed then :default_listeners will be taken from config
+      # @param [Hash] config to be passed to listeners during creation
+      # @param [String] custom_run_name Optional, to be passed to listeners during creation
+      def initialize(listeners, config, custom_run_name)
+
+        if listeners.empty?
+          config[:moto][:runner][:default_listeners].each do |listener_class_name|
+            listeners << listener_class_name
+          end
+        else
+          listeners.each_with_index do |listener_class_name, index|
+            listeners[index] = ('Moto::Reporting::Listeners::' + listener_class_name.camelize).constantize
+          end
+        end
+
+        @listeners = []
+        @config = config
+        @custom_run_name = custom_run_name
+        listeners.each { |l| add_listener(l) }
+      end
+
+      # Adds a listener to the list.
+      # All listeners on the list will have events reported to them.
+      # @param [Moto::Listener::Base] listener class to be added
+      def add_listener(listener)
+        @listeners << listener.new(listener_config(listener), @custom_run_name)
+      end
+
+      # @return [Hash] hash containing part of the config meant for a specific listener
+      # @param [Moto::Listener::Base] listener class for which config is to be retrieved
+      def listener_config(listener)
+        listener_symbol = listener.name.demodulize.underscore.to_sym
+        @config[:moto][:listeners][listener_symbol]
+      end
+
+      # Reports start of the whole run (set of tests) to attached listeners
+      def report_start_run
+        @run_status = Moto::Reporting::RunStatus.new
+        @run_status.initialize_run
+
+        @listeners.each do |l|
+          l.start_run
+        end
+      end
+
+      # Reports end of the whole run (set of tests) to attached listeners
+      def report_end_run
+        @run_status.finalize_run
+
+        @listeners.each do |l|
+          l.end_run(@run_status)
+        end
+      end
+
+      # Reports star of a test to all attached listeners
+      # @param [Moto::Test::Status] test_status of test which's start is to be reported on
+      def report_start_test(test_status)
+        @listeners.each do |l|
+          l.start_test(test_status)
+        end
+      end
+
+      # Reports end of a test to all attached listeners
+      # @param [Moto::Test::Status] test_status of test which's end is to be reported on
+      def report_end_test(test_status)
+        @run_status.add_test_status(test_status)
+
+        @listeners.each do |l|
+          l.end_test(test_status)
+        end
+      end
+
+    end
+  end
+end

data/lib/runner.rb

@@ -1,44 +1,33 @@
+require_relative './reporting/test_reporter'
+
 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
+    attr_reader :test_reporter
 
-    def initialize(tests, listeners, environments, config, name)
+    def initialize(tests, environments, config, test_reporter)
       @tests = tests
       @config = config
       @thread_pool = ThreadPool.new(my_config[:thread_count] || 1)
-      @name = name
+      @test_reporter = test_reporter
 
       # TODO: initialize logger from config (yml or just ruby code)
       # @logger = Logger.new(STDOUT)
       @logger = Logger.new(File.open("#{MotoApp::DIR}/moto.log", File::WRONLY | File::APPEND | File::CREAT))
       # @logger.level = Logger::WARN
 
-      @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
 
+    # TODO: Remake
+    # @return [Hash] hash with config
     def my_config
       caller_path = caller.first.to_s.split(/:\d/)[0]
       keys = []
@@ -56,17 +45,17 @@ module Moto
     end
 
     def run
-      @listeners.each { |l| l.start_run }
+      @test_reporter.report_start_run
 
       @tests.each do |test|
         @thread_pool.schedule do
-          tc = ThreadContext.new(self, test)
+          tc = ThreadContext.new(self, test, @test_reporter)
           tc.run
         end
       end
 
       @thread_pool.shutdown
-      @listeners.each { |l| l.end_run }
+      @test_reporter.report_end_run
     end
 
   end

data/lib/test/base.rb

@@ -0,0 +1,168 @@
+require_relative 'status'
+
+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
+      attr_accessor :evaled
+      attr_accessor :status
+
+      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
+
+      # Initializes test to be executed with specified params and environment
+      def init(env, params, params_index)
+        @env = env
+        @params = params
+        @name = generate_name(params_index)
+
+        @status = Moto::Test::Status.new
+        @status.name = @name
+        @status.test_class_name = self.class.name
+        @status.env = @env
+        @status.params = @params
+      end
+
+      # Generates name of the test based on its properties:
+      #  - number/name of currently executed configuration run
+      #  - env
+      def generate_name(params_index)
+        if @env == :__default
+          return "#{self.class.to_s}" if @params.empty?
+          return "#{self.class.to_s}/#{@params['__name']}" if @params.key?('__name')
+          return "#{self.class.to_s}/params_#{params_index}" unless @params.key?('__name')
+        else
+          return "#{self.class.to_s}/#{@env}" if @params.empty?
+          return "#{self.class.to_s}/#{@env}/#{@params['__name']}" if @params.key?('__name')
+          return "#{self.class.to_s}/#{@env}/params_#{params_index}" unless @params.key?('__name')
+        end
+        self.class.to_s
+      end
+      private :generate_name
+
+      # Setter for :log_path
+      def log_path=(param)
+        @log_path = param
+
+        # I hate myself for doing this, but I have no other idea for now how to pass log to Listeners that
+        # make use of it (for example WebUI)
+        @status.log_path = param
+      end
+
+      # @return [String] string with the path to the test's log
+      def log_path
+        @log_path
+      end
+
+      def dir
+        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
+
+      # Use this to run test
+      # Initializes status, runs test, handles exceptions, finalizes status after run completion
+      def run_test
+        status.initialize_run
+
+        begin
+          run
+        rescue Exception => exception
+          status.log_exception(exception)
+          raise
+        ensure
+          status.finalize_run
+        end
+
+      end
+
+      # Only to be overwritten by final test execution
+      # Use :run_test in order to run test
+      def run
+        # abstract
+      end
+
+      def before
+        # abstract
+      end
+
+      def after
+        # abstract
+      end
+
+      def skip(msg = nil)
+        raise Exceptions::TestSkipped.new(msg.nil? ? 'Test skipped with no reason given.' : "Skip reason: #{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
+
+
+      # Checks for equality of both arguments
+      def assert_equal(a, b)
+        assert(a == b, "Arguments should be equal: #{a} != #{b}.")
+      end
+
+      # Checks if passed value is equal to True
+      def assert_true(value)
+        assert(value, 'Logical condition not met, expecting true, given false.')
+      end
+
+      # Checks if passed value is equal to False
+      def assert_false(value)
+        assert(!value, 'Logical condition not met, expecting false, given true.')
+      end
+
+      # Checks if result of condition equals to True
+      def assert(condition, message)
+        if !condition
+          if evaled
+            # -1 because of added method header in generated class
+            line_number = caller.select { |l| l.match(/\(eval\):\d*:in `run'/) }.first[/\d+/].to_i - 1
+          else
+            line_number = caller.select { |l| l.match(/#{static_path}:\d*:in `run'/) }.first[/\d+/].to_i - 1
+          end
+
+          status.log_failure("ASSERTION FAILED in line #{line_number}: #{message}")
+          logger.error(message)
+        end
+      end
+
+    end
+  end
+end

data/lib/test/result.rb

@@ -0,0 +1,28 @@
+module Moto
+  module Test
+
+    # Value object representing information about results of a single attempt to pass the test
+    class Result
+
+      RUNNING  = :running   # -1
+      PASSED   = :passed    # 0
+      FAILURE  = :failure   # 1
+      ERROR    = :error     # 2
+      SKIPPED  = :skipped   # 3
+
+      # Result code of a single test run
+      attr_accessor :code
+
+      # Optional message that might accompany the result of a single test run
+      attr_accessor :message
+
+      # An Array of Strings representing messages that accompany assertion and forced failures
+      attr_accessor :failures
+
+      def initialize
+        @failures = []
+      end
+
+    end
+  end
+end

data/lib/test/status.rb

@@ -0,0 +1,106 @@
+require_relative 'result'
+
+module Moto
+  module Test
+
+    # Representation of single test's run status - it's passes, failures etc.
+    # Pretty much a value object which's purpose is to be passed as a data provider for listeners.
+    # Only methods here are just meant for data preparation. No communication with any external classes.
+    class Status
+
+      # Name of the test
+      attr_accessor :name
+
+      # Name of the class representing test
+      attr_accessor :test_class_name
+
+      # Array of [Moto::Test::Result], each item represents a result of a single attempt to pass the test
+      attr_reader :results
+
+      # Environment on which test was run
+      attr_accessor :env
+
+      # Set of params on which test was based
+      attr_accessor :params
+
+      # Time of test's start
+      attr_accessor :time_start
+
+      # Time of test's finish
+      attr_accessor :time_end
+
+      # Test's duration
+      attr_accessor :duration
+
+      # TODO: Burn it with fire...
+      # Path to test's log, for purpose of making test logs accessible via listeners
+      attr_accessor :log_path
+
+      def initialize
+        @results = []
+      end
+
+      def initialize_run
+        if @time_start.nil?
+          @time_start = Time.now.to_f
+        end
+
+        result = Moto::Test::Result.new
+        result.code = Moto::Test::Result::RUNNING
+        @results.push(result)
+      end
+
+      #
+      def finalize_run
+        last_result = @results.last
+
+        if last_result.code == Moto::Test::Result::RUNNING
+          last_result.code = Moto::Test::Result::PASSED
+        end
+
+        @time_end = Time.now.to_f
+        @duration = time_end - time_start
+      end
+
+      # Evaluates result.code and message based on exceptions, dispatched by test during test attempt
+      # @param [Exception] exception thrown during test run
+      def log_exception(exception)
+        current_result = @results.last
+
+        if exception.nil? || exception.is_a?(Moto::Exceptions::TestForcedPassed)
+          current_result.code = Moto::Test::Result::PASSED
+          current_result.message = exception.message
+        elsif exception.is_a?(Moto::Exceptions::TestSkipped)
+          current_result.code = Moto::Test::Result::SKIPPED
+          current_result.message = exception.message
+        elsif exception.is_a?(Moto::Exceptions::TestForcedFailure)
+         log_failure(exception.message)
+        else
+          current_result.code = Moto::Test::Result::ERROR
+          current_result.message = exception.message
+        end
+      end
+
+      # Logs a failure, from assertion or forced, to the list of failures
+      # @param [String] message of a failure to be added to the list
+      def log_failure(message)
+        current_result = @results.last
+        current_result.code = Moto::Test::Result::FAILURE
+        current_result.failures.push(message)
+      end
+
+
+      # Overwritten definition of to string.
+      # @return [String] string with readable form of @results.last.code
+      def to_s
+        case @results.last.code
+          when Moto::Test::Result::PASSED   then return 'PASSED'
+          when Moto::Test::Result::FAILURE  then return 'FAILED'
+          when Moto::Test::Result::ERROR    then return 'ERROR'
+          when Moto::Test::Result::SKIPPED  then return 'SKIPPED'
+        end
+      end
+
+    end
+  end
+end