moto 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b968b33356b5ded74aa5f2fc317bd573aa49012a
-  data.tar.gz: f0a9e4c04b7039a3f709fe4ab46dbaa19e3433d9
+  metadata.gz: edd2e049b0e7dba56343581d50e61e9a88026eb7
+  data.tar.gz: 17e66c69f025ae75cf1b42c019024bd91812a715
 SHA512:
-  metadata.gz: 8e1a15ea13bf8b97a41ac473170bc5e535f70f99b5584823ff35044504a9b8aa80ed4bfea8f4f9c5a8112ac5075ed3e9e7129e3da89f56828ae2fccd881e79d6
-  data.tar.gz: 3ace513d0a6bb0a989b03c1a6e6d7f6e48810f6139d3d18121a01e498532eb5e81f1914916966635a640c8096d89d09e09a09a9505bfcf2f38b40935a2467367
+  metadata.gz: 5e34d0f3514791a3ddc4ff69820bbb81ceb7d1f3308925cb66aabd34db31c76b0e54ac03ad410685a23674a0009e6abaf7705566c0838497544c1adde822efe0
+  data.tar.gz: cc84b318230866656c81e91594dcce32e27d3538b375af3d5c0cb20d7d7303d86dd66c4cfda9afcce5e18ef5721457ce72d3b322fd3fb3b63228f022c7e5c976

data/lib/modes/mode_selector.rb

@@ -65,9 +65,8 @@ module Moto
 
       def prepare_test_reporter(parsed_arguments)
         run_params = {}
-        run_params[:run_name] = parsed_arguments[:run_name]
-        run_params[:suite_name] = parsed_arguments[:suite_name]
-        run_params[:assignee] = parsed_arguments[:assignee]
+        run_params[:mwui_path] = parsed_arguments[:mwui_path]
+        run_params[:mwui_assignee_id] = parsed_arguments[:mwui_assignee_id]
 
         Moto::Reporting::TestReporter.new(parsed_arguments[:listeners], run_params)
       end

data/lib/modes/run/test_provider.rb

@@ -49,13 +49,19 @@ module Moto
             @test_metadata = @tests_metadata.shift
           end
 
+          test_metadata = Marshal.load(Marshal.dump(@test_metadata))
+
+          if test_metadata
+            test_metadata.test_repeat = @current_test_repeat
+          end
+
           if @current_test_repeat == @test_repeats
             @current_test_repeat = 1
           else
             @current_test_repeat += 1
           end
 
-          @test_metadata
+          test_metadata
         end
         private :get_test_metadata
 

data/lib/parameter_parser.rb

@@ -68,9 +68,8 @@ module Moto
       # Default options
       options = {}
       options[:listeners] = []
-      options[:run_name] = nil
-      options[:suite_name] = nil
-      options[:assignee] = nil
+      options[:mwui_path] = nil
+      options[:mwui_assignee_id] = nil
       options[:stop_on] = {error: false, fail: false, skip: false}
 
       # Parse arguments
@@ -81,9 +80,8 @@ module Moto
         opts.on('-g', '--tags Tags', Array)           {|v| options[:tags] = v}
         opts.on('-f', '--filters Filters', Array)     {|v| options[:filters] = v}
         opts.on('-l', '--listeners Listeners', Array) {|v| options[:listeners] = v}
-        opts.on('-r', '--runname RunName')            {|v| options[:run_name] = v}
-        opts.on('-s', '--suitename SuiteName')        {|v| options[:suite_name] = v}
-        opts.on('-a', '--assignee Assignee')          {|v| options[:assignee] = v}
+        opts.on('--mwui-path MwuiPath')               {|v| options[:mwui_path] = v}
+        opts.on('--mwui-assignee-id MwuiAssignee')    {|v| options[:mwui_assignee_id] = v}
         opts.on('-c', '--config Config')              {|v| options[:config_name] = v}
         opts.on('--threads ThreadCount', Integer)     {|v| options[:threads] = v}
         opts.on('--attempts AttemptCount', Integer)   {|v| options[:attempts] = v}
@@ -104,10 +102,6 @@ module Moto
         end
       end
 
-      if options[:run_name].nil?
-        options[:run_name] = evaluate_name(options[:tests], options[:tags], options[:filters])
-      end
-
       # Runner configuration
 
       Moto::Lib::Config.moto[:test_runner][:thread_count] = options[:threads] if options[:threads]
@@ -139,24 +133,20 @@ module Moto
       # Default options
       options = {}
       options[:listeners] = []
-      options[:run_name] = nil
-      options[:suite_name] = nil
-      options[:assignee] = nil
 
       # Parse arguments
       OptionParser.new do |opts|
-        opts.on('-c', '--config Config') {|v| options[:config_name] = v}
-        opts.on('-t', '--tests Tests', Array) {|v| options[:tests] = v}
-        opts.on('-g', '--tags Tags', Array) {|v| options[:tags] = v}
-        opts.on('-f', '--filters Filters', Array) {|v| options[:filters] = v}
-        opts.on('-l', '--listeners Listeners', Array) {|v| options[:listeners] = v}
-        opts.on('-r', '--runname RunName') {|v| options[:run_name] = v}
-        opts.on('-s', '--suitename SuiteName') {|v| options[:suite_name] = v}
-        opts.on('-a', '--assignee Assignee') {|v| options[:assignee] = v}
-        opts.on('-p', '--tagregexpos RegexPositive') {|v| options[:validator_regex_positive] = v}
-        opts.on('-n', '--tagregexneg RegexNegative') {|v| options[:validator_regex_negative] = v}
-        opts.on('-h', '--hastags') {|v| options[:validate_has_tags] = v}
-        opts.on('-d', '--hasdescription') {|v| options[:validate_has_description] = v}
+        opts.on('-c', '--config Config')                    {|v| options[:config_name] = v}
+        opts.on('-t', '--tests Tests', Array)               {|v| options[:tests] = v}
+        opts.on('-g', '--tags Tags', Array)                 {|v| options[:tags] = v}
+        opts.on('-f', '--filters Filters', Array)           {|v| options[:filters] = v}
+        opts.on('-l', '--listeners Listeners', Array)       {|v| options[:listeners] = v}
+        opts.on('--mwui-path MwuiPath')                     {|v| options[:mwui_path] = v}
+        opts.on('--mwui-assignee-id MwuiAssignee')          {|v| options[:mwui_assignee_id] = v}
+        opts.on('-p', '--tagregexpos RegexPositive')        {|v| options[:validator_regex_positive] = v}
+        opts.on('-n', '--tagregexneg RegexNegative')        {|v| options[:validator_regex_negative] = v}
+        opts.on('-h', '--hastags')                          {|v| options[:validate_has_tags] = v}
+        opts.on('-d', '--hasdescription')                   {|v| options[:validate_has_description] = v}
         opts.on('-w', '--tagwhitelist TagWhitelist', Array) {|v| options[:tag_whitelist] = v}
       end.parse!
 
@@ -168,32 +158,9 @@ module Moto
         end
       end
 
-      if options[:run_name].nil?
-        options[:run_name] = evaluate_name(options[:tests], options[:tags], options[:filters])
-      end
-
       return options
     end
 
-    # Generate default name based on input parameters
-    def self.evaluate_name(tests, tags, filters)
-      name = ''
-
-      if tests
-        name << "Tests: #{tests.join(',')}  "
-      end
-
-      if tags
-        name << "Tags: #{tags.join(',')}  "
-      end
-
-      if filters
-        name << "Filters: #{filters.join(',')}  "
-      end
-
-      return name
-    end
-
     # Parses attributes passed to the application when run by 'moto generate'
     def self.generate_parse(argv)
       options = {}

data/lib/reporting/listeners/junit_xml.rb

@@ -13,7 +13,6 @@ module Moto
               errors:     run_status.tests_error.length,
               failures:   run_status.tests_failed.length,
               skipped:    run_status.tests_skipped.length,
-              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

@@ -9,92 +9,36 @@ module Moto
 
         REST_MAX_TRIES = 1
         REST_TIMEOUT = 15
+        REST_RESULTS_AT_ONCE = 500
 
         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.'
+          if run_params[:mwui_path].nil?
+            raise 'ERROR: Please specify directory path (--mwui-path /EXAMPLE/PATH) when using MotoWebUI as one of the listeners.'
+          else
+            @mwui_path = run_params[:mwui_path]
           end
 
-          if run_params[:assignee]
-            @assignee = run_params[:assignee]
+          if run_params[:mwui_assignee_id]
+            @assignee = run_params[:mwui_assignee_id]
           else
             @assignee = config[:default_assignee]
           end
 
           @tests = {}
-          @url = "#{config[:url]}/api"
+          @url = URI.escape("#{config[:url]}/api/motoresults")
           @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
-
-          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)
-
-          # 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
-          }
-
-          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)
-
-          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(response, symbolize_names: true)
         end
 
         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
+              name: test_status.display_name,
               start_time: Time.now
           }
 
@@ -110,62 +54,65 @@ module Moto
             test_data[:description] = test_metadata.description
           end
 
-          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})
-          }
-
-          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
+          # Store Test in a hash with its name as key so later it can be accessed
+          @tests[test_data[:name]] = test_data
         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 ? test_status.results.last.message : nil,
               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})
           }
 
-          test = JSON.parse(response, symbolize_names: true)
-
-          @tests[test_status.name] = test
+          @tests[test_status.display_name].merge!(test_data)
 
           # 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
+          # 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
 
-            url_log = "#{url_test}/logs"
-            log_data = { text: File.read(test_status.log_path) }.to_json
+
+        def end_run(run_status)
+          # Ultimately converts Hash to Array, which is going to be way more useful at this point
+          # Assignment is done to the same variable, instead of new one, in order to conserve memory since effectively
+          # we're just duplicating the same data
+          @tests = @tests.values
+
+          while !@tests.empty?
+            partial_run_data = {
+                path: @mwui_path,
+                tester_id: @assignee,
+                tests: @tests.shift(REST_RESULTS_AT_ONCE)
+            }.to_json
 
             response = try {
               RestClient::Request.execute(method: :post,
-                                          url: URI.escape(url_log),
-                                          payload: log_data,
+                                          url: @url,
+                                          payload: partial_run_data,
                                           timeout: REST_TIMEOUT,
                                           headers: {content_type: :json, accept: :json})
             }
+
+            response = JSON.parse(response, symbolize_names: true)
             response
           end
+
         end
 
         # @return [String] string with messages of all failures in a test

data/lib/reporting/test_reporter.rb

@@ -10,10 +10,6 @@ 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[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?
@@ -65,7 +61,7 @@ module Moto
         end
       end
 
-      # Reports star of a test to all attached listeners
+      # Reports start of a test to all attached listeners
       # @param [Moto::Test::Status] test_status of test which's start is to be reported on
       # @param [Moto::Test::Metadata] test_metadata of test which's start is to be reported on
       def report_start_test(test_status, test_metadata)

data/lib/test/base.rb

@@ -40,6 +40,7 @@ module Moto
         @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.display_name += "(#{metadata.test_repeat})" if metadata.test_repeat > 1
       end
 
       # Setter for :log_path

data/lib/test/metadata.rb

@@ -6,6 +6,9 @@ module Moto
       # Absolute test path
       attr_reader :test_path
 
+      # Indicates which repetition of the same test is represented by this metadata
+      attr_accessor :test_repeat
+
       # @param [String] test_path Absolute path to file with test
       def initialize(test_path)
         @test_path = test_path

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Moto
-  VERSION = '1.0.7'
+  VERSION = '1.0.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moto
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Bartek Wilczek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-29 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport