moto 0.8.8 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07c4d34bc9210a0b733b4f611128acaff34fd1a3
-  data.tar.gz: ab4e1346e86d2844fa5bafd3fe0a6518c939d8d6
+  metadata.gz: 4207f74793c80ef13675cb7eb98f8125e7f251ab
+  data.tar.gz: f5be5e7a42a02407a03db6a2622d9ffc28af7635
 SHA512:
-  metadata.gz: 5026888d22631ff1ae2d42c9347ceae346f0bbbb45870fd7d57595c062697697ea349c421c1b4f67fb079dfe24fed67f9ee45b34dbd78ce30a1bcc466dd10376
-  data.tar.gz: 834a3b7c45f9c05c84f4e167a26da28a04e377edd0cbbc1a19c3bf6be2f8ab4294a7013ffb97dfc00dba4d46b92eb4ab894d96afb560dbe52dd99f58b57f8a76
+  metadata.gz: 925d4a8275fbe9a7c865282c3678161771cd647ae4d770d339984b14083e24885b2a66da7abad143a7d87e34777b925083e137cb5e1a4d0dc05b5eb4652277bf
+  data.tar.gz: 2cd6b32278b60a09f4dbcc65ad5f58d5e8da892e0faa1cd2b4e6082d038cf71f10f8338051bd58975cda7ca96050367ea7bcffd2c17e5a340e9fa914d5c05a2c

data/lib/cli.rb

@@ -18,6 +18,7 @@ require_relative './runner/test_runner'
 require_relative './runner/thread_context'
 require_relative './runner/test_generator'
 require_relative './test/base'
+require_relative './test/metadata'
 require_relative './version'
 require_relative './reporting/listeners/base'
 require_relative './reporting/listeners/console'
@@ -35,14 +36,16 @@ module Moto
   class Cli
     def self.run(argv)
 
-      test_paths_absolute = []
+      tests_metadata = []
       directories   = argv[:tests]
       tags          = argv[:tags]
       filters       = argv[:filters]
 
       if directories
         directories.each do |directory|
-          test_paths_absolute += Dir.glob("#{MotoApp::DIR}/tests/#{directory}/**/*.rb")
+          Dir.glob("#{MotoApp::DIR}/tests/#{directory}/**/*.rb").each do |test_path|
+            tests_metadata << Moto::Test::Metadata.new(test_path)
+          end
         end
       end
 
@@ -50,51 +53,40 @@ module Moto
         tests_total = Dir.glob("#{MotoApp::DIR}/tests/**/*.rb")
         tests_total.each do |test_path|
 
-          test_body = File.read(test_path)
-          matches = test_body.match(/^#(\s*)MOTO_TAGS:(.*?)$/)
-
-          if matches
-            test_tags = matches.to_a[2].gsub(/\s*/, '').split(',')
-            test_paths_absolute << test_path unless (tags & test_tags).empty?
-          end
+          metadata = Moto::Test::Metadata.new(test_path)
+          tests_metadata << metadata unless (tags & metadata.tags).empty?
 
         end
       end
 
       # Make sure there are no repetitions in gathered set
-      test_paths_absolute.uniq!
+      tests_metadata.uniq! { |metadata| metadata.test_path }
 
       # Tests to be removed due to filtering will be gathered in this array
       # [].delete(item) cannot be used since it interferes with [].each
-      filtered_test_paths = []
+      unfit_metadata = []
 
       # Filter tests by provied tags
+      # - test must contain ALL tags specified with -f param
+      # - test may contain other tags
       if filters
-        test_paths_absolute.each do |test_path|
-          test_body = File.read(test_path)
-
-          matches = test_body.match(/^#(\s*)MOTO_TAGS:(.*?)$/)
-
-          if matches
-
-            test_tags = matches.to_a[2].gsub(/\s*/, '').split(',')
-            if (filters & test_tags).empty?
-              # Test doesn't contain any tags to be filtered upon
-              filtered_test_paths << test_path
-            end
-
-          else
-            # Test has no tags at all
-            filtered_test_paths << test_path
+        tests_metadata.each do |metadata|
+
+          # If test has no tags at all and filters are set it should be automatically removed
+          if metadata.tags.empty?
+            unfit_metadata << metadata
+          # Otherwise check provided tags and filters for compatibility
+          elsif (metadata.tags & filters).length != filters.length
+            unfit_metadata << metadata
           end
 
         end
       end
 
-      test_paths_absolute -= filtered_test_paths
+      tests_metadata -= unfit_metadata
 
       #TODO Display criteria used
-      if test_paths_absolute.empty?
+      if tests_metadata.empty?
         puts 'No tests found for given arguments.'
         Kernel.exit(-1)
       end
@@ -107,9 +99,14 @@ module Moto
         initializer.init
       end
 
-      test_reporter = Moto::Reporting::TestReporter.new(argv[:listeners], argv[:name])
+      run_params = {}
+      run_params[:run_name]   = argv[:run_name]
+      run_params[:suite_name] = argv[:suite_name]
+      run_params[:assignee]   = argv[:assignee]
+
+      test_reporter = Moto::Reporting::TestReporter.new(argv[:listeners], run_params)
 
-      runner = Moto::Runner::TestRunner.new(test_paths_absolute, test_reporter, argv[:stop_on])
+      runner = Moto::Runner::TestRunner.new(tests_metadata, test_reporter, argv[:stop_on])
       runner.run
     end
 

data/lib/parser.rb

@@ -34,9 +34,11 @@ module Moto
 
       # Default options
       options = {}
-      options[:listeners] = []
-      options[:name] = ''
-      options[:stop_on] = {error: false, fail: false, skip: false}
+      options[:listeners]   = []
+      options[:run_name]    = nil
+      options[:suite_name]  = nil
+      options[:assignee]    = nil
+      options[:stop_on]     = {error: false, fail: false, skip: false}
 
       # Parse arguments
       OptionParser.new do |opts|
@@ -45,17 +47,20 @@ module Moto
         opts.on('-f', '--filters Filters', Array)          { |v| options[:filters]      = v }
         opts.on('-l', '--listeners Listeners', Array)      { |v| options[:listeners]    = v }
         opts.on('-e', '--environment Environment')         { |v| options[:environment]  = v }
-        opts.on('-n', '--name Name')                       { |v| options[:name]         = v }
+        opts.on('-r', '--run RunName')                     { |v| options[:run_name]     = v }
+        opts.on('-s', '--suite SuiteName')                 { |v| options[:suite_name]   = v }
+        opts.on('-a', '--assignee Assignee')               { |v| options[:assignee]     = v }
         opts.on('-c', '--config Config')                   { |v| options[:config_name]  = v }
         opts.on('--stop-on-error')                         { options[:stop_on][:error] = true }
         opts.on('--stop-on-fail')                          { options[:stop_on][:fail]  = true }
         opts.on('--stop-on-skip')                          { options[:stop_on][:skip]  = true }
       end.parse!
 
-      if options[:name].empty?
-        options[:name] = evaluate_name(options[:tags], options[:tests], options[:filters])
+      if options[:run_name].nil?
+        options[:run_name] = evaluate_name(options[:tags], options[:tests], options[:filters])
       end
 
+
       if options[:environment]
         Moto::Lib::Config.environment = options[:environment]
         Moto::Lib::Config.load_configuration(options[:config_name] ? options[:config_name] : 'moto')
@@ -111,25 +116,36 @@ module Moto
       Moto (#{Moto::VERSION}) CLI Help:
       moto --version Display current version
 
-      moto run:      
+      MOTO RUN:
        -t, --tests       Tests to be executed.
        -g, --tags        Tags of tests to be executed.
                          Use # MOTO_TAGS: TAGNAME in test to assign tag.
        -f, --filters     Tags that filter tests passed via -t parameter.
-                         Only tests in appropriate directory, having appropriate tag will be executed.
-                         Use # MOTO_TAGS: TAGNAME in test to assign tag.
-       -l, --listeners   Reporters to be used.
-                         Defaults are Moto::Reporting::Listeners::ConsoleDots, Moto::Reporting::Listeners::JunitXml
-                         One reporter that is always used: Moto::Reporting::Listeners::KernelCode
+                         Only tests in appropriate directory, having all of the specified tags will be executed.
+                         Use # MOTO_TAGS: TAGNAME1 in test to assign tag.
+
+
        -e, --environment Mandatory environment. Environment constants and tests parametrized in certain way depend on this.
        -c, --config      Name of the config, without extension, to be loaded from MotoApp/config/CONFIG_NAME.rb
                          Default: moto (which loads: MotoApp/config/moto.rb)
+
+
+       -l, --listeners   Reporters to be used.
+                         Defaults are Moto::Reporting::Listeners::ConsoleDots, Moto::Reporting::Listeners::JunitXml
+                         One reporter that is always used: Moto::Reporting::Listeners::KernelCode
+       -s, --suitename   Name of the test suite to which should aggregate the results of current test run.
+                         Required when specifying MotoWebUI as one of the listeners.
+       -r, --runname     Name of the test run to which everything will be reported when using MotoWebUI.
+                         Default: Value of -g or -t depending on which one was specified.
+       -a, --assignee    ID of a person responsible for current test run.
+                         Can have a default value set in config/webui section.
+
        --stop-on-error   Moto will stop test execution when an error is encountered in test results
        --stop-on-fail    Moto will stop test execution when a failure is encountered in test results
        --stop-on-skip    Moto will stop test execution when a skip is encountered in test results
 
 
-      moto generate:
+      MOTO GENERATE:
        -t, --test        Path and name of the test to be created.
                          Examples:
                          -ttest_name          will create MotoApp/tests/test_name/test_name.rb

data/lib/reporting/listeners/base.rb

@@ -5,11 +5,11 @@ module Moto
       # Base class for listeners that report results of testing 'outside' of the application.
       class Base
 
-        attr_reader :custom_run_name
+        attr_reader :run_params
 
-        # @param [String] custom_run_name Optional run name to be passed to listeners
-        def initialize(custom_run_name = '')
-          @custom_run_name = custom_run_name
+        # @param [String] run_params Described in detail in [Moto::Reporting::TestReporter]
+        def initialize(run_params)
+          @run_params = run_params
         end
 
         # Invoked when whole batch of tests starts
@@ -25,7 +25,7 @@ module Moto
 
         # Abstract
         # Invoked when a single test is started
-        def start_test(test_status)
+        def start_test(test_status, test_metadata)
           # Abstract
         end
 

data/lib/reporting/listeners/console.rb

@@ -17,10 +17,6 @@ module Moto
           puts "  Skipped:      #{run_status.tests_skipped.length}"
         end
 
-        def start_test(test_status)
-         # puts test_status.name
-        end
-
         def end_test(test_status)
           puts "\n#{test_status.name}\n\t#{test_status.results.last.message}"
         end

data/lib/reporting/listeners/junit_xml.rb

@@ -13,7 +13,7 @@ module Moto
               errors:     run_status.tests_error.length,
               failures:   run_status.tests_failed.length,
               skipped:    run_status.tests_skipped.length,
-              name:       custom_run_name,
+              name:       run_params[:run_name],
               tests:      run_status.tests_all.length,
               time:       run_status.duration,
               timestamp:  Time.at(run_status.time_start)

data/lib/reporting/listeners/webui.rb

@@ -1,103 +1,177 @@
 require 'rest-client'
 require 'sys/uname'
+require 'uri'
 
 module Moto
   module Reporting
     module Listeners
       class Webui < Base
 
-        REST_MAX_TRIES = 3
+        REST_MAX_TRIES = 1
         REST_TIMEOUT = 15
 
-        def start_run
+        def initialize(run_params)
+          super
+
+          if run_params[:suite_name].nil?
+            raise 'ERROR: Please specify suite name (-s SUITE_NAME) when using MotoWebUI as one of the listeners.'
+          end
+
+          if run_params[:assignee]
+            @assignee = run_params[:assignee]
+          else
+            @assignee = config[:default_assignee]
+          end
 
-          @url = config[:url]
+          @tests = {}
+          @url = "#{config[:url]}/api"
           @send_log_on_pass = config[:send_log_on_pass]
+        end
+
+
+        def start_run
+
+          # Create Suite, if it did exist already nothing new will be created and existing data will be sent in the response
+          url_suites = "#{@url}/suites"
+          suite_data = {name: run_params[:suite_name]}.to_json
 
-          data = {
-              name: custom_run_name,
-              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
+          response = try {
+            RestClient::Request.execute(method: :post,
+                                                 url: URI.escape(url_suites),
+                                                 payload: suite_data,
+                                                 timeout: REST_TIMEOUT,
+                                                 headers: {content_type: :json, accept: :json})
           }
+          suite = JSON.parse(response, symbolize_names: true)
 
-          result = try {
-            RestClient::Request.execute(method: :post, url: "#{@url}/api/runs", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          # Store ID of current Suite
+          @suite_id = suite[:id]
+
+          # Prepare data for new TestRun
+          url_runs = "#{@url}/suites/#{@suite_id}/runs"
+          run_data = {
+              name: run_params[:run_name],
+              start_time: Time.now
           }
 
-          @run = JSON.parse(result)
-          @tests = {}
+          if @assignee
+            run_data[:tester_id] = @assignee
+          end
+
+          run_data = run_data.to_json
+
+          # Create new TestRun based on prepared data
+          response = try {
+            RestClient::Request.execute(method: :post,
+                                                 url: URI.escape(url_runs),
+                                                 payload: run_data,
+                                                 timeout: REST_TIMEOUT,
+                                                 headers: {content_type: :json, accept: :json})
+          }
+
+          @run = JSON.parse(response, symbolize_names: true)
         end
 
+
         def end_run(run_status)
-          # PUT http://sandbox.dev:3000/api/runs/1
-          data = {
-              result: run_status.result,
-              cnt_all: run_status.tests_all.length,
-              cnt_passed: run_status.tests_passed.length,
-              cnt_failure: run_status.tests_failed.length,
-              cnt_error: run_status.tests_error.length,
-              cnt_skipped: run_status.tests_skipped.length,
-              duration: run_status.duration
-          }
 
-          result = try {
-              RestClient::Request.execute(method: :put, url: "#{@url}/api/runs/#{@run['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          url_run = "#{@url}/suites/#{@suite_id}/runs/#{@run[:id]}"
+          run_data = {
+              duration: (Time.now.to_f - run_status.time_start).to_i
+          }.to_json
+
+          response = try {
+            RestClient::Request.execute(method: :put,
+                                        url: URI.escape(url_run),
+                                        payload: run_data,
+                                        timeout: REST_TIMEOUT,
+                                        headers: {content_type: :json, accept: :json})
           }
-          @run = JSON.parse(result)
+          @run = JSON.parse(response, symbolize_names: true)
         end
 
-        def start_test(test_status)
-          # POST http://sandbox.dev:3000/api/tests/create
-          data = {
-              name: test_status.name,
-              class_name: test_status.test_class_name,
-              log: nil,
-              run_id: @run['id'],
-              env: test_status.env,
-              parameters: test_status.params.to_s,
-              result: :running,
-              error: nil,
-              failures: nil
-          }
 
-          result = try {
-            RestClient::Request.execute(method: :post, url: "#{@url}/api/tests", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+        def start_test(test_status, test_metadata)
+
+          # Prepare data for new Test
+          url_tests = "#{@url}/suites/#{@suite_id}/runs/#{@run[:id]}/tests"
+          test_data = {
+              name: test_status.display_name, #test_status.test_class_name
+              start_time: Time.now
           }
-          @tests[test_status.name] = JSON.parse(result)
-        end
 
-        def end_test(test_status)
+          if test_metadata.ticket_url
+            test_data[:ticket_url] = test_metadata.ticket_url
+          end
 
-          # don't send the log if the test has passed and appropriate flag is set to false
-          if test_status.results.last.code == Moto::Test::Result::PASSED && !@send_log_on_pass
-            full_log = nil
-          else
-            full_log = File.read(test_status.log_path)
+          if test_metadata.tags
+            test_data[:tags] = test_metadata.tags.join(',')
           end
 
-          data = {
-              log: full_log,
-              result: test_status.results.last.code,
-              error: test_status.results.last.code == Moto::Test::Result::ERROR ? nil : test_status.results.last.message,
-              failures: test_failures(test_status),
-              duration: test_status.duration
+          test_data = test_data.to_json
+
+          # Create new Test based on prepared data
+          response = try {
+            RestClient::Request.execute(method: :post,
+                                                 url: URI.escape(url_tests),
+                                                 payload: test_data,
+                                                 timeout: REST_TIMEOUT,
+                                                 headers: {content_type: :json, accept: :json})
           }
 
-          result = try {
-            RestClient::Request.execute(method: :put, url: "#{@url}/api/tests/#{@tests[test_status.name]['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          test = JSON.parse(response, symbolize_names: true)
+
+          # Store Test in a hash with its name as key so later it can be accessed and server side ID can be retrieved
+          @tests[test[:name]] = test
+        end
+
+
+        def end_test(test_status)
+
+          url_test = "#{@url}/suites/#{@suite_id}/runs/#{@run[:id]}/tests/#{@tests[test_status.display_name][:id]}"
+          test_data = {
+              duration: (Time.now.to_f - test_status.time_start).to_i,
+              error_message: test_status.results.last.code == Moto::Test::Result::ERROR ? nil : test_status.results.last.message,
+              fail_message: test_failures(test_status),
+              result_id: webui_result_id(test_status.results.last.code),
+          }.to_json
+
+          # Create new Test based on prepared data
+          response = try {
+            RestClient::Request.execute(method: :put,
+                                                 url: URI.escape(url_test),
+                                                 payload: test_data,
+                                                 timeout: REST_TIMEOUT,
+                                                 headers: {content_type: :json, accept: :json})
           }
-          @tests[test_status.name] = JSON.parse(result)
+
+          test = JSON.parse(response, symbolize_names: true)
+
+          @tests[test_status.name] = test
+
+          # Add Log to already existing Test
+          if (test_status.results.last.code == Moto::Test::Result::PASSED && @send_log_on_pass) || test_status.results.last.code != Moto::Test::Result::PASSED
+
+            url_log = "#{url_test}/logs"
+            log_data = { text: File.read(test_status.log_path) }.to_json
+
+            response = try {
+              RestClient::Request.execute(method: :post,
+                                          url: URI.escape(url_log),
+                                          payload: log_data,
+                                          timeout: REST_TIMEOUT,
+                                          headers: {content_type: :json, accept: :json})
+            }
+            response
+          end
         end
 
         # @return [String] string with messages of all failures in a test
         def test_failures(test_status)
+          if test_status.results.last.failures.empty?
+            return nil
+          end
+
           test_status.results.last.failures.join("\n\t")
         end
 
@@ -121,6 +195,22 @@ module Moto
         end
         private :config
 
+        def webui_result_id(code)
+          case code
+            when Moto::Test::Result::RUNNING
+              1
+            when Moto::Test::Result::PASSED
+              2
+            when Moto::Test::Result::FAILURE
+              3
+            when Moto::Test::Result::ERROR
+              4
+            when Moto::Test::Result::SKIPPED
+              5
+          end
+        end
+        private :webui_result_id
+
       end
     end
   end

data/lib/reporting/listeners/webui_deprecated.rb

@@ -0,0 +1,127 @@
+require 'rest-client'
+require 'sys/uname'
+
+module Moto
+  module Reporting
+    module Listeners
+      class WebuiDeprecated < Base
+
+        REST_MAX_TRIES = 3
+        REST_TIMEOUT = 15
+
+        def start_run
+
+          @url = config[:url]
+          @send_log_on_pass = config[:send_log_on_pass]
+
+          data = {
+              name: run_params[:name],
+              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
+          }
+
+          result = try {
+            RestClient::Request.execute(method: :post, url: "#{@url}/api/runs", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          }
+
+          @run = JSON.parse(result)
+          @tests = {}
+        end
+
+        def end_run(run_status)
+          # PUT http://sandbox.dev:3000/api/runs/1
+          data = {
+              result: run_status.result,
+              cnt_all: run_status.tests_all.length,
+              cnt_passed: run_status.tests_passed.length,
+              cnt_failure: run_status.tests_failed.length,
+              cnt_error: run_status.tests_error.length,
+              cnt_skipped: run_status.tests_skipped.length,
+              duration: run_status.duration
+          }
+
+          result = try {
+              RestClient::Request.execute(method: :put, url: "#{@url}/api/runs/#{@run['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          }
+          @run = JSON.parse(result)
+        end
+
+        def start_test(test_status, test_metadata)
+          # POST http://sandbox.dev:3000/api/tests/create
+          data = {
+              name: test_status.name,
+              class_name: test_status.test_class_name,
+              log: nil,
+              run_id: @run['id'],
+              env: test_status.env,
+              parameters: test_status.params.to_s,
+              result: :running,
+              error: nil,
+              failures: nil
+          }
+
+          result = try {
+            RestClient::Request.execute(method: :post, url: "#{@url}/api/tests", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          }
+          @tests[test_status.name] = JSON.parse(result)
+        end
+
+        def end_test(test_status)
+
+          # don't send the log if the test has passed and appropriate flag is set to false
+          if test_status.results.last.code == Moto::Test::Result::PASSED && !@send_log_on_pass
+            full_log = nil
+          else
+            full_log = File.read(test_status.log_path)
+          end
+
+          data = {
+              log: full_log,
+              result: test_status.results.last.code,
+              error: test_status.results.last.code == Moto::Test::Result::ERROR ? nil : test_status.results.last.message,
+              failures: test_failures(test_status),
+              duration: test_status.duration
+          }
+
+          result = try {
+            RestClient::Request.execute(method: :put, url: "#{@url}/api/tests/#{@tests[test_status.name]['id']}", payload: data.to_json, timeout: REST_TIMEOUT, headers: {content_type: :json, accept: :json})
+          }
+          @tests[test_status.name] = JSON.parse(result)
+        end
+
+        # @return [String] string with messages of all failures in a test
+        def test_failures(test_status)
+          test_status.results.last.failures.join("\n\t")
+        end
+
+        # Tries to execute, without an error, block of code passed to the function.
+        # @param block Block of code to be executed up to MAX_REST_TRIES
+        def try(&block)
+
+          tries = REST_MAX_TRIES
+
+          begin
+            yield
+          rescue
+            tries -= 1
+            tries > 0 ? retry : raise
+          end
+        end
+
+        # @return [Hash] Hash with config for WebUI
+        def config
+          Moto::Lib::Config.moto[:test_reporter][:listeners][:webui]
+        end
+        private :config
+
+      end
+    end
+  end
+end

data/lib/reporting/test_reporter.rb

@@ -11,8 +11,11 @@ module Moto
 
       # @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 [String] custom_run_name Optional, to be passed to listeners during creation
-      def initialize(listeners, custom_run_name)
+      # @param[Hash] run_params Variables specified by the user when parametrizing current moto run
+      #       suite_name: String Name of the test suite
+      #       run_name:   String Name of the test run, may be custom made or automatically generated
+      #       assignee:   ID of person responsible for test run
+      def initialize(listeners, run_params)
 
         if listeners.empty?
           config[:default_listeners].each do |listener_class_name|
@@ -25,7 +28,7 @@ module Moto
         end
 
         @listeners = []
-        @custom_run_name = custom_run_name
+        @run_params = run_params
         listeners.each { |l| add_listener(l) }
       end
 
@@ -33,7 +36,7 @@ module Moto
       # 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(@custom_run_name)
+        @listeners << listener.new(@run_params)
       end
 
       # Reports start of the whole run (set of tests) to attached listeners
@@ -57,9 +60,10 @@ module Moto
 
       # 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)
+      # @param [Moto::Test::Metadata] test_metadata of test which's start is to be reported on
+      def report_start_test(test_status, test_metadata)
         @listeners.each do |l|
-          l.start_test(test_status)
+          l.start_test(test_status, test_metadata)
         end
       end
 

data/lib/runner/test_generator.rb

@@ -15,11 +15,11 @@ module Moto
       #   Example: A test with no config file will be returned as an array with single Moto::Test::Base in it.
       #   Example: A test with a config file and 2 sets of parameters there will be returned as array with two elements.
       #
-      # @param [String] test_path_absolute Path to the test that is about to be instantiated.
-      # @return [Array] An array of [Moto::Test::Base] decendants
+      # @param [Moto::Test::Metadata] test_metadata Metadata that describes test to be instantiated
+      # @return [Array] An array of [Moto::Test::Base] descendants
       #                 each entry is a Test with set of parameters injected
-      def get_test_with_variants(test_path_absolute)
-        test_path_absolute ? variantize(test_path_absolute) : nil
+      def get_test_with_variants(test_metadata)
+        variantize(test_metadata)
       end
 
       # Converts test's path to an array of Moto::Base::Test instances that represent all test variants (params)
@@ -28,19 +28,18 @@ module Moto
       # Config files with ruby code will be evaluated thus if you use any classes in them
       # they must be required prior to that. That might be done in overloaded app's initializer.
       #
-      # @param [String] test_path_absolute Path to the file with test
+      # @param [Moto::Test::Metadata] test_metadata Metadata that describes test to be instantiated, contains path to test
       # @return [Array] array of already initialized test's variants
-      def variantize(test_path_absolute)
+      def variantize(test_metadata)
         variants = []
 
           # TODO CHANGED TEMPORARY
           #params_path = test_path_absolute.sub(/\.rb\z/, '')
-          params_directory = File.dirname(test_path_absolute).to_s + '/params/**'
+          params_directory = File.dirname(test_metadata.test_path).to_s + '/params/**'
           param_files_paths = Dir.glob(params_directory)
           param_files_paths = [nil] if param_files_paths.empty?
 
-          #TODO Fix
-          param_files_paths.each_with_index do |params_path, params_index|
+          param_files_paths.each do |params_path|
 
             #TODO environment support
             # Filtering out param sets that are specific to certain envs
@@ -50,9 +49,9 @@ module Moto
             # end
 
             #TODO Name/logname/displayname
-            test = generate(test_path_absolute)
-            test.init(params_path, params_index, @internal_counter)
-            test.log_path = "#{File.dirname(test_path_absolute).to_s}/logs/#{test.name.gsub(/[^0-9A-Za-z.\-]/, '_')}.log"
+            test = generate(test_metadata)
+            test.init(params_path)
+            test.log_path = "#{File.dirname(test_metadata.test_path).to_s}/logs/#{test.name.gsub(/[^0-9A-Za-z.\-]/, '_')}.log"
             @internal_counter += 1
 
             variants << test
@@ -64,24 +63,27 @@ module Moto
 
       # Generates test instances
       # @return [Moto::Test::Base]
-      def generate(test_path_absolute)
+      def generate(test_metadata)
+
+        test_path = test_metadata.test_path
 
         # Checking if it's possible to create test based on provided path. In case something is wrong with
         # modules structure in class itself Moto::Test::Base will be instantized with raise injected into its run()
         # so we can have proper reporting and summary even if the test doesn't execute.
         begin
-          require test_path_absolute
-          class_name = test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb').constantize
+          require test_path
+          class_name = test_path.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb').constantize
           test_object = class_name.new
         rescue NameError => e
           class_name = Moto::Test::Base
           test_object = class_name.new
 
-          error_message = "ERROR: Invalid test: #{test_path_absolute.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb')}.\nMESSAGE: #{e}"
+          error_message = "ERROR: Invalid test: #{test_path.gsub("#{MotoApp::DIR}/", 'moto_app/').camelize.chomp('.rb')}.\nMESSAGE: #{e}"
           inject_error_to_test(test_object, error_message)
         end
 
-        test_object.static_path = test_path_absolute
+        test_object.static_path = test_path
+        test_object.metadata = test_metadata
         test_object
       end
       private :generate

data/lib/runner/test_provider.rb

@@ -6,13 +6,13 @@ module Moto
     # Thread safe provider of test instances
     class TestProvider
 
-      # @param [Array] test_paths_absolute
-      def initialize(test_paths_absolute)
+      # @param [Array] tests_metadata
+      def initialize(tests_metadata)
         super()
         @test_repeats = Moto::Lib::Config.moto[:test_runner][:test_repeats]
         @current_test_repeat = 1
         @queue = Queue.new
-        @test_paths_absolute = test_paths_absolute
+        @tests_metadata = tests_metadata
         @test_generator = TestGenerator.new
       end
 
@@ -26,9 +26,10 @@ module Moto
       def create_tests
         if @queue.empty?
 
-          test_variants = @test_generator.get_test_with_variants(get_test_path)
+          test_metadata = get_test_metadata
 
-          if test_variants
+          if test_metadata
+            test_variants = @test_generator.get_test_with_variants(test_metadata)
             test_variants.each do |test|
               @queue.push(test)
             end
@@ -38,12 +39,12 @@ module Moto
       end
       private :create_tests
 
-      # Returns path to the test while supporting the number of repeats specified by the user
-      # return [String] Path to the test
-      def get_test_path
+      # Returns metadata of the test while supporting the number of repeats specified by the user
+      # return [Moto::Test::Metadata]
+      def get_test_metadata
 
         if @current_test_repeat == 1
-          @test_path = @test_paths_absolute.shift
+          @test_metadata = @tests_metadata.shift
         end
 
         if @current_test_repeat == @test_repeats
@@ -52,9 +53,9 @@ module Moto
           @current_test_repeat += 1
         end
 
-        @test_path
+        @test_metadata
       end
-      private :get_test_path
+      private :get_test_metadata
 
       # Number of threads waiting for a job
       def num_waiting

data/lib/runner/test_runner.rb

@@ -7,25 +7,25 @@ module Moto
 
       attr_reader :test_reporter
 
-      # @param [Array] test_paths_absolute Absolute paths to files with tests
+      # @param [Array] tests_metadata Collection of [Moto::Test::Metadata] objects describing Tests
       # @param [Moto::Reporting::TestReporter] test_reporter Reporter of test/run statuses that communicates with external status listeners
       # @param [Hash] stop_conditions Describe when TestRunner should abnormally stop its execution
       #   :error  [Boolean]
       #   :fail   [Boolean]
       #   :skip   [Boolean]
-      def initialize(test_paths_absolute, test_reporter, stop_conditions)
-        @test_paths_absolute = test_paths_absolute
+      def initialize(tests_metadata, test_reporter, stop_conditions)
+        @tests_metadata = tests_metadata
         @test_reporter = test_reporter
         @stop_conditions = stop_conditions
       end
 
       def run
-        test_provider = TestProvider.new(@test_paths_absolute)
+        test_provider = TestProvider.new(@tests_metadata)
         threads_max = Moto::Lib::Config.moto[:test_runner][:thread_count] || 1
 
         # remove log/screenshot files from previous execution
-        @test_paths_absolute.each do |test_path|
-          FileUtils.rm_rf("#{File.dirname(test_path)}/logs")
+        @tests_metadata.each do |metadata|
+          FileUtils.rm_rf("#{File.dirname(metadata.test_path)}/logs")
         end
 
         @test_reporter.report_start_run

data/lib/runner/thread_context.rb

@@ -26,7 +26,7 @@ module Moto
         sleep_time   = config[:test_attempt_sleep] || 0
 
         # Reporting: start_test
-        @test_reporter.report_start_test(@test.status)
+        @test_reporter.report_start_test(@test.status, @test.metadata)
 
         (1..max_attempts).each do |attempt|
 

data/lib/test/base.rb

@@ -10,6 +10,10 @@ module Moto
       attr_accessor :static_path
       attr_accessor :status
 
+      # Contains information specified by user in Test headers, marked with appropriate tags
+      # @return [Moto::Test::Metadata]
+      attr_accessor :metadata
+
       class << self
         attr_accessor :_path
       end
@@ -23,17 +27,19 @@ module Moto
       end
 
       # Initializes test to be executed with specified params and environment
-      def init(params_path, params_index, global_index)
+      def init(params_path)
         @env = Moto::Lib::Config.environment
         @params = []
         @params_path = params_path
-        #TODO Display name
+
         @name = self.class.to_s.demodulize
-        @name += "_#{@params_path.split("/")[-1].chomp('.param')}" if @params_path
+        @name += "_#{@params_path.split('/')[-1].chomp('.param')}" if @params_path
+
         @status = Moto::Test::Status.new
         @status.name = @name
         @status.test_class_name = self.class.name
         @status.display_name = @status.test_class_name.split('::')[2..-2].join('::')
+        @status.display_name += "_#{@params_path.split('/')[-1].chomp('.param')}" if @params_path
         @status.env = Moto::Lib::Config.environment
       end
 

data/lib/test/metadata.rb

@@ -0,0 +1,77 @@
+module Moto
+  module Test
+    # Provides tools for accessing metadata embedded in test files
+    class Metadata
+
+      # Absolute test path
+      attr_reader :test_path
+
+      # @param [String] test_path Absolute path to file with test
+      def initialize(test_path)
+        @test_path = test_path
+      end
+
+      # Text of the file with test
+      def text
+        if @text.nil?
+          @text = ''
+
+          File.foreach(@test_path) do |line|
+
+            # Read lines of file until class specification begins
+            if line.match(/^\s*(class|module)/)
+              break
+            end
+
+            @text += line
+          end
+
+        end
+
+        @text
+      end
+      private :text
+
+      # @return [Array] of [String] which represent contents of #MOTO_TAGS
+      def tags
+        if @tags.nil?
+          matches = text.match(/^#(\s*)MOTO_TAGS:(.*?)$/)
+
+          if matches
+            @tags = matches.to_a[2].gsub(/\s*/, '').split(',')
+          else
+            @tags = []
+          end
+        end
+
+        @tags
+      end
+
+      # @return [String] which represents contents of #TICKET_URL
+      def ticket_url
+        if @ticket_url.nil?
+          matches = text.match(/^#(\s*)TICKET_URL:(.*?)$/)
+
+          if matches
+            @ticket_url = matches.to_a[2].gsub(/\s*/, '')
+          else
+            @ticket_url = ''
+          end
+        end
+
+        @ticket_url
+      end
+
+      # Overriden eql? so various comparisons, array substractions etc. can be perfromed on
+      # Metadata objects with them being represented by test's location
+      def eql?(other)
+        if self.class == other.class
+          return self.test_path == other.test_path
+        end
+
+        false
+      end
+
+    end
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Moto
-  VERSION = '0.8.8'
+  VERSION = '0.9.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.9.1
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-13 00:00:00.000000000 Z
+date: 2016-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -99,6 +99,7 @@ files:
 - lib/reporting/listeners/console_dots.rb
 - lib/reporting/listeners/junit_xml.rb
 - lib/reporting/listeners/webui.rb
+- lib/reporting/listeners/webui_deprecated.rb
 - lib/reporting/run_status.rb
 - lib/reporting/test_reporter.rb
 - lib/runner/test_generator.rb
@@ -107,6 +108,7 @@ files:
 - lib/runner/thread_context.rb
 - lib/runner_logging.rb
 - lib/test/base.rb
+- lib/test/metadata.rb
 - lib/test/result.rb
 - lib/test/status.rb
 - lib/test_logging.rb
@@ -131,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Moto - yet another web testing framework