hybrid_platforms_conductor 33.0.0 → 33.0.1

data/lib/hybrid_platforms_conductor/provisioner.rb

@@ -22,8 +22,8 @@ module HybridPlatformsConductor
     def initialize(
       node,
       environment: 'production',
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       nodes_handler: NodesHandler.new,
@@ -80,7 +80,7 @@ module HybridPlatformsConductor
             @config.ssh_connection_transforms.replace(@config.ssh_connection_transforms.map do |ssh_transform_info|
               {
                 nodes_selectors_stack: ssh_transform_info[:nodes_selectors_stack].map do |nodes_selector|
-                  @nodes_handler.select_nodes(nodes_selector).select { |selected_node| selected_node != @node }
+                  @nodes_handler.select_nodes(nodes_selector).reject { |selected_node| selected_node == @node }
                 end,
                 transform: ssh_transform_info[:transform]
               }
@@ -154,7 +154,7 @@ module HybridPlatformsConductor
           begin
             Socket.tcp(instance_ip, port, connect_timeout: remaining_timeout) { true }
           rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EADDRNOTAVAIL, Errno::ETIMEDOUT
-            log_warn "[ #{@node}/#{@environment} ] - Can't connect to #{instance_ip}:#{port}: #{$!}"
+            log_warn "[ #{@node}/#{@environment} ] - Can't connect to #{instance_ip}:#{port}: #{$ERROR_INFO}"
             false
           end
         sleep 1 unless port_listening

data/lib/hybrid_platforms_conductor/report.rb

@@ -15,8 +15,8 @@ module HybridPlatformsConductor
     # * *platforms_handler* (PlatformsHandler): Platforms handler to be used. [default: PlatformsHandler.new]
     # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       platforms_handler: PlatformsHandler.new,
       nodes_handler: NodesHandler.new

data/lib/hybrid_platforms_conductor/reports_handler.rb

@@ -26,8 +26,8 @@ module HybridPlatformsConductor
     # * *platforms_handler* (PlatformsHandler): Platforms handler to be used. [default = PlatformsHandler.new]
     # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default = NodesHandler.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       platforms_handler: PlatformsHandler.new,
       nodes_handler: NodesHandler.new
@@ -70,6 +70,7 @@ module HybridPlatformsConductor
     # * *nodes_selectors* (Array<Object>): List of nodes selectors to produce report for
     def produce_report_for(nodes_selectors)
       raise "Unknown locale for format #{@format}: #{@locale}" unless @reports_plugins[@format].supported_locales.include? @locale
+
       @reports_plugins[@format].new(
         logger: @logger,
         logger_stderr: @logger_stderr,

data/lib/hybrid_platforms_conductor/secrets_reader.rb

@@ -15,8 +15,8 @@ module HybridPlatformsConductor
     # * *cmd_runner* (CmdRunner): CmdRunner to be used. [default: CmdRunner.new]
     # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       nodes_handler: NodesHandler.new

data/lib/hybrid_platforms_conductor/services_handler.rb

@@ -21,7 +21,8 @@ module HybridPlatformsConductor
 
     @packaged_deployments = []
 
-    include LoggerHelpers, ParallelThreads
+    include ParallelThreads
+    include LoggerHelpers
 
     # Constructor
     #
@@ -34,8 +35,8 @@ module HybridPlatformsConductor
     # * *nodes_handler* (NodesHandler): Nodes Handler to be used. [default: NodesHandler.new]
     # * *actions_executor* (ActionsExecutor): Actions Executor to be used. [default: ActionsExecutor.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       platforms_handler: PlatformsHandler.new,
@@ -56,13 +57,11 @@ module HybridPlatformsConductor
     #
     # Parameters::
     # * *services* (Hash< String, Array<String> >): Services to be deployed, per node
-    # * *secrets* (Hash): Secrets to be used for deployment
     # * *local_environment* (Boolean): Are we deploying to a local environment?
     # Result::
     # * String or nil: Reason for which we are not allowed to deploy, or nil if deployment is authorized
     def deploy_allowed?(
       services:,
-      secrets:,
       local_environment:
     )
       if local_environment
@@ -83,7 +82,7 @@ module HybridPlatformsConductor
             head_commit_id = git.log.first.sha
             git.branches.all? do |branch|
               branch.gcommit.objectish.include?(' -> ') || (
-                !(branch.full == 'master' || branch.full =~ /^remotes\/.+\/master$/) || branch.gcommit.sha != head_commit_id
+                !(branch.full == 'master' || branch.full =~ %r{^remotes/.+/master$}) || branch.gcommit.sha != head_commit_id
               )
             end
           end
@@ -108,25 +107,25 @@ module HybridPlatformsConductor
       local_environment:
     )
       platforms_for(services).each do |platform, platform_services|
-        if platform.respond_to?(:package)
-          platform_name = platform.name
-          # Compute the package ID that is unique to this packaging, so that we don't mix it with others if needed.
-          package_id = {
-            platform_name: platform_name,
-            services: Hash[platform_services.map { |node, node_services| [node, node_services.sort] }].sort,
-            secrets: secrets.sort,
+        next unless platform.respond_to?(:package)
+
+        platform_name = platform.name
+        # Compute the package ID that is unique to this packaging, so that we don't mix it with others if needed.
+        package_id = {
+          platform_name: platform_name,
+          services: platform_services.transform_values(&:sort).sort,
+          secrets: secrets.sort,
+          local_environment: local_environment
+        }
+        if ServicesHandler.packaged_deployments.include?(package_id)
+          log_debug "Platform #{platform_name} has already been packaged for this deployment (package ID #{package_id}). Won't package it another time."
+        else
+          platform.package(
+            services: platform_services,
+            secrets: secrets,
             local_environment: local_environment
-          }
-          if ServicesHandler.packaged_deployments.include?(package_id)
-            log_debug "Platform #{platform_name} has already been packaged for this deployment (package ID #{package_id}). Won't package it another time."
-          else
-            platform.package(
-              services: platform_services,
-              secrets: secrets,
-              local_environment: local_environment
-            )
-            ServicesHandler.packaged_deployments << package_id
-          end
+          )
+          ServicesHandler.packaged_deployments << package_id
         end
       end
     end
@@ -145,12 +144,14 @@ module HybridPlatformsConductor
       why_run:
     )
       platforms_for(services).each do |platform, platform_services|
+        next unless platform.respond_to?(:prepare_for_deploy)
+
         platform.prepare_for_deploy(
           services: platform_services,
           secrets: secrets,
           local_environment: local_environment,
           why_run: why_run
-        ) if platform.respond_to?(:prepare_for_deploy)
+        )
       end
     end
 
@@ -164,10 +165,11 @@ module HybridPlatformsConductor
     # * Array< Hash<Symbol,Object> >: List of actions to be done
     def actions_to_deploy_on(node, services, why_run)
       services.map do |service|
-        platform = @platforms_handler.known_platforms.find { |platform| platform.deployable_services.include?(service) }
+        platform = @platforms_handler.known_platforms.find { |search_platform| search_platform.deployable_services.include?(service) }
         raise "No platform is able to deploy the service #{service}" if platform.nil?
+
         # Add some markers in stdout and stderr so that parsing services-oriented deployment output is easier
-        deploy_marker = "===== [ #{node} / #{service} ] - HPC Service #{why_run ? 'Check' : 'Deploy' } ====="
+        deploy_marker = "===== [ #{node} / #{service} ] - HPC Service #{why_run ? 'Check' : 'Deploy'} ====="
         [{
           ruby: proc do |stdout, stderr|
             stdout << "#{deploy_marker} Begin\n"
@@ -210,7 +212,7 @@ module HybridPlatformsConductor
     end
 
     # Regexp: The marker regexp used to separate services deployment
-    MARKER_REGEXP = /^===== \[ (.+?) \/ (.+?) \] - HPC Service (\w+) ===== Begin$(.+?)^===== \[ \1 \/ \2 \] - HPC Service \3 ===== End$/m
+    MARKER_REGEXP = %r{^===== \[ (.+?) / (.+?) \] - HPC Service (\w+) ===== Begin$(.+?)^===== \[ \1 / \2 \] - HPC Service \3 ===== End$}m
 
     # Parse stdout and stderr of a given deploy run and get the list of tasks with their status, organized per service and node deployed.
     #
@@ -234,8 +236,9 @@ module HybridPlatformsConductor
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed node #{stdout_node}, stderr deployed node #{stderr_node}" unless stdout_node == stderr_node
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed service #{stdout_service}, stderr deployed service #{stderr_service}" unless stdout_service == stderr_service
         log_warn "Mismatch in deployment logs between stdout and stderr: stdout deployed mode is #{stdout_mode}, stderr deployed mode is #{stderr_mode}" unless stdout_mode == stderr_mode
-        platform = @platforms_handler.known_platforms.find { |platform| platform.deployable_services.include?(stdout_service) }
+        platform = @platforms_handler.known_platforms.find { |search_platform| search_platform.deployable_services.include?(stdout_service) }
         raise "No platform is able to deploy the service #{stdout_service}" if platform.nil?
+
         {
           node: stdout_node,
           service: stdout_service,

data/lib/hybrid_platforms_conductor/test_only_remote_node.rb

@@ -10,7 +10,7 @@ module HybridPlatformsConductor
     def self.only_on_nodes
       # Just 1 node per service and platform
       Test.nodes_handler.prefetch_metadata_of Test.nodes_handler.known_nodes, :local_node
-      Test.nodes_handler.known_nodes.select { |node| !Test.nodes_handler.get_local_node_of(node) }
+      Test.nodes_handler.known_nodes.reject { |node| Test.nodes_handler.get_local_node_of(node) }
     end
 
   end

data/lib/hybrid_platforms_conductor/test_report.rb

@@ -50,7 +50,7 @@ module HybridPlatformsConductor
     # Result::
     # * Array<Test>: List of platform tests
     def platform_tests
-      @tests.select { |test| !test.platform.nil? }
+      @tests.reject { |test| test.platform.nil? }
     end
 
     # Return node tests
@@ -58,7 +58,7 @@ module HybridPlatformsConductor
     # Result::
     # * Array<Test>: List of node tests
     def node_tests
-      @tests.select { |test| !test.node.nil? }
+      @tests.reject { |test| test.node.nil? }
     end
 
     # Select tests corresponding to a given criteria
@@ -144,7 +144,7 @@ module HybridPlatformsConductor
             when :only_as_expected
               test.expected_failure ? test.errors : []
             when :only_as_non_expected
-              !test.expected_failure ? test.errors : []
+              test.expected_failure ? [] : test.errors
             else
               raise "Unknown errors filter: #{fiter}"
             end
@@ -166,10 +166,10 @@ module HybridPlatformsConductor
         end
         groups = {}
         tests.group_by(&first_criteria).each do |first_group, grouped_tests|
-          next_grouped_errors = group_errors(grouped_tests, *group_criterias[1..-1], filter: filter)
+          next_grouped_errors = group_errors(grouped_tests, *group_criterias[1..], filter: filter)
           groups[first_group] = next_grouped_errors unless next_grouped_errors.empty?
         end
-        Hash[groups.sort]
+        groups.sort.to_h
       end
     end
 
@@ -184,7 +184,7 @@ module HybridPlatformsConductor
     #   * *tested_nodes_in_error_as_expected* (Array<String>): Tested nodes in error in the list that are part of the expected failures
     def nodes_by_nodes_list
       no_list_nodes = @nodes_handler.known_nodes
-      Hash[(
+      (
         @nodes_handler.known_nodes_lists.sort.map do |nodes_list|
           nodes_from_list = @nodes_handler.nodes_from_list(nodes_list, ignore_unknowns: true)
           no_list_nodes -= nodes_from_list
@@ -193,17 +193,14 @@ module HybridPlatformsConductor
           ['No list', no_list_nodes],
           ['All', @nodes_handler.known_nodes]
         ]
-      ).map do |list_name, list_nodes|
-        [
-          list_name,
-          {
-            nodes: list_nodes,
-            tested_nodes: list_nodes & @tested_nodes,
-            tested_nodes_in_error: list_nodes & group_errors(node_tests, :node).keys,
-            tested_nodes_in_error_as_expected: list_nodes & group_errors(node_tests, :node, filter: :only_as_expected).keys
-          }
-        ]
-      end]
+      ).to_h.transform_values do |list_nodes|
+        {
+          nodes: list_nodes,
+          tested_nodes: list_nodes & @tested_nodes,
+          tested_nodes_in_error: list_nodes & group_errors(node_tests, :node).keys,
+          tested_nodes_in_error_as_expected: list_nodes & group_errors(node_tests, :node, filter: :only_as_expected).keys
+        }
+      end
     end
 
     # Flatten a tree hash.
@@ -259,7 +256,7 @@ module HybridPlatformsConductor
     #     * *not_run*: All non-successful tests have not been run
     def classify_tests(tests)
       info = {
-        not_run: tests.select { |test| !test.executed? },
+        not_run: tests.reject(&:executed?),
         success: tests.select { |test| test.executed? && test.errors.empty? },
         unexpected_error: tests.select { |test| test.executed? && !test.errors.empty? && test.expected_failure.nil? },
         expected_error: tests.select { |test| test.executed? && !test.errors.empty? && !test.expected_failure.nil? }

data/lib/hybrid_platforms_conductor/tests_runner.rb

@@ -12,7 +12,8 @@ module HybridPlatformsConductor
   # Class running tests
   class TestsRunner
 
-    include LoggerHelpers, ParallelThreads
+    include ParallelThreads
+    include LoggerHelpers
 
     # List of tests to execute [default: []]
     # Array<Symbol>
@@ -50,8 +51,8 @@ module HybridPlatformsConductor
     # * *actions_executor* (ActionsExecutor): Actions Executor to be used for the tests [default: ActionsExecutor.new]
     # * *deployer* (Deployer): Deployer to be used for the tests needed why-run deployments [default: Deployer.new]
     def initialize(
-      logger: Logger.new(STDOUT),
-      logger_stderr: Logger.new(STDERR),
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
       config: Config.new,
       cmd_runner: CmdRunner.new,
       platforms_handler: PlatformsHandler.new,
@@ -74,10 +75,10 @@ module HybridPlatformsConductor
       @reports_plugins = Plugins.new(:test_report, logger: @logger, logger_stderr: @logger_stderr)
       # Register test classes from platforms
       @platforms_handler.known_platforms.each do |platform|
-        if platform.respond_to?(:tests)
-          platform.tests.each do |test_name, test_class|
-            @tests_plugins[test_name] = test_class
-          end
+        next unless platform.respond_to?(:tests)
+
+        platform.tests.each do |test_name, test_class|
+          @tests_plugins[test_name] = test_class
         end
       end
       # Do we skip running check-node?
@@ -146,6 +147,7 @@ module HybridPlatformsConductor
       @reports.sort!
       unknown_tests = @tests - @tests_plugins.keys
       raise "Unknown test names: #{unknown_tests.join(', ')}" unless unknown_tests.empty?
+
       @nodes = @nodes_handler.select_nodes(nodes_selectors).uniq.sort
 
       # Resolve the expected failures from the config.
@@ -173,11 +175,11 @@ module HybridPlatformsConductor
       @platforms_handler.known_platforms.each do |platform|
         platform_nodes = platform.known_nodes
         @node_expected_failures.each do |test_name, expected_failures_for_test|
-          if (platform_nodes - expected_failures_for_test.keys).empty?
-            # We have an expected failure for this test
-            @platform_expected_failures[test_name] = {} unless @platform_expected_failures.key?(test_name)
-            @platform_expected_failures[test_name][platform.name] = expected_failures_for_test.values.uniq.join(' + ')
-          end
+          next unless (platform_nodes - expected_failures_for_test.keys).empty?
+
+          # We have an expected failure for this test
+          @platform_expected_failures[test_name] = {} unless @platform_expected_failures.key?(test_name)
+          @platform_expected_failures[test_name][platform.name] = expected_failures_for_test.values.uniq.join(' + ')
         end
       end
 
@@ -191,24 +193,24 @@ module HybridPlatformsConductor
       run_tests_connection_on_nodes
       run_tests_on_check_nodes
 
-      @tested_platforms = @tests_run.map { |test| test.platform }.compact.uniq.sort
+      @tested_platforms = @tests_run.map(&:platform).compact.uniq.sort
 
       # Check that tests that were expected to fail did not succeed.
       @tests_run.each do |test|
-        if test.executed?
-          expected_failure = test.expected_failure
-          if expected_failure
-            if test.errors.empty?
-              # Should have failed
-              error(
-                "Test #{test} was marked to fail (#{expected_failure}) but it succeeded. Please remove it from the expected failures in case the issue has been resolved.",
-                platform: test.platform,
-                node: test.node,
-                force_failure: true
-              )
-            else
-              out "Expected failure for #{test} (#{expected_failure}):\n#{test.errors.map { |error| "  - #{error}" }.join("\n")}".yellow
-            end
+        next unless test.executed?
+
+        expected_failure = test.expected_failure
+        if expected_failure
+          if test.errors.empty?
+            # Should have failed
+            error(
+              "Test #{test} was marked to fail (#{expected_failure}) but it succeeded. Please remove it from the expected failures in case the issue has been resolved.",
+              platform: test.platform,
+              node: test.node,
+              force_failure: true
+            )
+          else
+            out "Expected failure for #{test} (#{expected_failure}):\n#{test.errors.map { |error| "  - #{error}" }.join("\n")}".yellow
           end
         end
       end
@@ -217,14 +219,12 @@ module HybridPlatformsConductor
         @node_expected_failures.each do |test_name, test_expected_failures|
           test_expected_failures.each do |node, expected_failure|
             # Check that a test has been run for this expected failure
-            unless @tests_run.find do |test|
-                test.name == test_name &&
-                  (
-                    (test.node.nil? && node == '') ||
-                    (!test.node.nil? && node == test.node)
-                  )
-              end
-              error("A test named #{test_name} for node #{node} was expected to fail (#{expected_failure}), but no test has been run. Please remove it from the expected failures if this expected failure is obsolete.")
+            error("A test named #{test_name} for node #{node} was expected to fail (#{expected_failure}), but no test has been run. Please remove it from the expected failures if this expected failure is obsolete.") unless @tests_run.find do |test|
+              test.name == test_name &&
+                (
+                  (test.node.nil? && node == '') ||
+                  (!test.node.nil? && node == test.node)
+                )
             end
           end
         end
@@ -232,11 +232,9 @@ module HybridPlatformsConductor
 
       # Produce reports
       @reports.each do |report|
-        begin
-          @reports_plugins[report].new(@logger, @logger_stderr, @config, @nodes_handler, @nodes, @tested_platforms, @tests_run).report
-        rescue
-          log_error "Uncaught exception while producing report #{report}: #{$!}\n#{$!.backtrace.join("\n")}"
-        end
+        @reports_plugins[report].new(@logger, @logger_stderr, @config, @nodes_handler, @nodes, @tested_platforms, @tests_run).report
+      rescue
+        log_error "Uncaught exception while producing report #{report}: #{$ERROR_INFO}\n#{$ERROR_INFO.backtrace.join("\n")}"
       end
 
       out
@@ -285,6 +283,9 @@ module HybridPlatformsConductor
         name: test_name.nil? ? :global : test_name,
         platform: platform,
         node: node,
+        # Keep this else on purpose to show where global tests could have expected failures
+        # rubocop:disable Style/EmptyElse
+        # rubocop:disable Lint/DuplicateBranch
         expected_failure: if ignore_expected_failure
                             nil
                           elsif !node.nil?
@@ -297,6 +298,8 @@ module HybridPlatformsConductor
                             # Global test
                             nil
                           end
+        # rubocop:enable Lint/DuplicateBranch
+        # rubocop:enable Style/EmptyElse
       )
     end
 
@@ -333,38 +336,38 @@ module HybridPlatformsConductor
           []
         end
       end.flatten
-      unless tests_to_run.empty?
-        section "Run #{tests_to_run.size} #{title}" do
-          tests_preparation.call(tests_to_run) unless tests_preparation.nil?
-          for_each_element_in(
-            tests_to_run,
-            parallel: !log_debug? && nbr_threads_max > 1,
-            nbr_threads_max: nbr_threads_max,
-            progress: "Run #{title}"
-          ) do |test|
-            test_category =
-              if test.platform.nil? && test.node.nil?
-                'Global'
-              elsif test.node.nil?
-                "Platform #{test.platform.name}"
-              elsif test.platform.nil?
-                "Node #{test.node}"
-              else
-                "Platform #{test.platform.name} / Node #{test.node}"
-              end
-            out "[ #{Time.now.utc.strftime('%F %T')} ] - [ #{test_category} ] - [ #{test.name} ] - Start test..."
-            begin_time = Time.now
-            begin
-              test_execution.call(test)
-            rescue
-              test.error "Uncaught exception during test: #{$!}", $!.backtrace.join("\n")
+      return if tests_to_run.empty?
+
+      section "Run #{tests_to_run.size} #{title}" do
+        tests_preparation&.call(tests_to_run)
+        for_each_element_in(
+          tests_to_run,
+          parallel: !log_debug? && nbr_threads_max > 1,
+          nbr_threads_max: nbr_threads_max,
+          progress: "Run #{title}"
+        ) do |test|
+          test_category =
+            if test.platform.nil? && test.node.nil?
+              'Global'
+            elsif test.node.nil?
+              "Platform #{test.platform.name}"
+            elsif test.platform.nil?
+              "Node #{test.node}"
+            else
+              "Platform #{test.platform.name} / Node #{test.node}"
             end
-            end_time = Time.now
-            test.executed
-            out "[ #{Time.now.utc.strftime('%F %T')} ] - [ #{test_category} ] - [ #{test.name} ] - Test finished in #{end_time - begin_time} seconds."
+          out "[ #{Time.now.utc.strftime('%F %T')} ] - [ #{test_category} ] - [ #{test.name} ] - Start test..."
+          begin_time = Time.now
+          begin
+            test_execution.call(test)
+          rescue
+            test.error "Uncaught exception during test: #{$ERROR_INFO}", $ERROR_INFO.backtrace.join("\n")
           end
-          @tests_run.concat(tests_to_run)
+          end_time = Time.now
+          test.executed
+          out "[ #{Time.now.utc.strftime('%F %T')} ] - [ #{test_category} ] - [ #{test.name} ] - Test finished in #{end_time - begin_time} seconds."
         end
+        @tests_run.concat(tests_to_run)
       end
     end
 
@@ -411,21 +414,19 @@ module HybridPlatformsConductor
           # Hash< String, Array< [ String, Hash<Symbol,Object> ] > >
           @cmds_to_run = {}
           selected_tests.each do |test|
-            begin
-              test.test_on_node.each do |cmd, test_info|
-                test_info_normalized = test_info.is_a?(Hash) ? test_info.clone : { validator: test_info }
-                test_info_normalized[:timeout] = DEFAULT_CMD_TIMEOUT unless test_info_normalized.key?(:timeout)
-                test_info_normalized[:test] = test
-                @cmds_to_run[test.node] = [] unless @cmds_to_run.key?(test.node)
-                @cmds_to_run[test.node] << [
-                  cmd,
-                  test_info_normalized
-                ]
-              end
-            rescue
-              test.error "Uncaught exception during test preparation: #{$!}", $!.backtrace.join("\n")
-              test.executed
+            test.test_on_node.each do |cmd, test_info|
+              test_info_normalized = test_info.is_a?(Hash) ? test_info.clone : { validator: test_info }
+              test_info_normalized[:timeout] = DEFAULT_CMD_TIMEOUT unless test_info_normalized.key?(:timeout)
+              test_info_normalized[:test] = test
+              @cmds_to_run[test.node] = [] unless @cmds_to_run.key?(test.node)
+              @cmds_to_run[test.node] << [
+                cmd,
+                test_info_normalized
+              ]
             end
+          rescue
+            test.error "Uncaught exception during test preparation: #{$ERROR_INFO}", $ERROR_INFO.backtrace.join("\n")
+            test.executed
           end
           # Compute the timeout that will be applied, from the max timeout sum for every node that has tests to run
           timeout = CONNECTION_TIMEOUT + (
@@ -435,21 +436,18 @@ module HybridPlatformsConductor
           )
           # Run commands on nodes, in grouped way to avoid too many connections, per node
           # Hash< String, Array<String> >
-          @test_cmds = Hash[@cmds_to_run.map do |node, cmds_list|
-            [
-              node,
-              {
-                remote_bash: cmds_list.map do |(cmd, _test_info)|
-                  [
-                    "echo '#{CMD_SEPARATOR}'",
-                    ">&2 echo '#{CMD_SEPARATOR}'",
-                    cmd,
-                    "echo \"$?\""
-                  ]
-                end.flatten
-              }
-            ]
-          end]
+          @test_cmds = @cmds_to_run.transform_values do |cmds_list|
+            {
+              remote_bash: cmds_list.map do |(cmd, _test_info)|
+                [
+                  "echo '#{CMD_SEPARATOR}'",
+                  ">&2 echo '#{CMD_SEPARATOR}'",
+                  cmd,
+                  'echo "$?"'
+                ]
+              end.flatten
+            }
+          end
           section "Run test commands on #{@test_cmds.keys.size} connected nodes (timeout to #{timeout} secs)" do
             start_time = Time.now
             @actions_executor.max_threads = @max_threads_connection_on_nodes
@@ -469,7 +467,7 @@ module HybridPlatformsConductor
             if exit_status.is_a?(Symbol)
               test.error "Error while executing tests: #{exit_status}: #{stderr}"
             else
-              log_debug <<~EOS
+              log_debug <<~EO_LOG
                 ----- Commands for #{test.node}:
                 #{@test_cmds[test.node][:remote_bash].join("\n")}
                 ----- STDOUT:
@@ -477,23 +475,23 @@ module HybridPlatformsConductor
                 ----- STDERR:
                 #{stderr}
                 -----
-              EOS
+              EO_LOG
               # Skip the first section, as it can contain SSH banners
-              cmd_stdouts = stdout.split("#{CMD_SEPARATOR}\n")[1..-1]
+              cmd_stdouts = stdout.split("#{CMD_SEPARATOR}\n")[1..]
               cmd_stdouts = [] if cmd_stdouts.nil?
-              cmd_stderrs = stderr.split("#{CMD_SEPARATOR}\n")[1..-1]
+              cmd_stderrs = stderr.split("#{CMD_SEPARATOR}\n")[1..]
               cmd_stderrs = [] if cmd_stderrs.nil?
               @cmds_to_run[test.node].zip(cmd_stdouts, cmd_stderrs).each do |(cmd, test_info), cmd_stdout, cmd_stderr|
                 # Find the section that corresponds to this test
-                if test_info[:test] == test
-                  cmd_stdout = '' if cmd_stdout.nil?
-                  cmd_stderr = '' if cmd_stderr.nil?
-                  stdout_lines = cmd_stdout.split("\n")
-                  # Last line of stdout is the return code
-                  return_code = stdout_lines.empty? ? :command_cant_run : Integer(stdout_lines.last)
-                  test.error "Command '#{cmd}' returned error code #{return_code}", "----- STDOUT:\n#{stdout_lines[0..-2].join("\n")}\n----- STDERR:\n#{cmd_stderr}" unless return_code == 0
-                  test_info[:validator].call(stdout_lines[0..-2], cmd_stderr.split("\n"), return_code)
-                end
+                next unless test_info[:test] == test
+
+                cmd_stdout = '' if cmd_stdout.nil?
+                cmd_stderr = '' if cmd_stderr.nil?
+                stdout_lines = cmd_stdout.split("\n")
+                # Last line of stdout is the return code
+                return_code = stdout_lines.empty? ? :command_cant_run : Integer(stdout_lines.last)
+                test.error "Command '#{cmd}' returned error code #{return_code}", "----- STDOUT:\n#{stdout_lines[0..-2].join("\n")}\n----- STDERR:\n#{cmd_stderr}" unless return_code.zero?
+                test_info[:validator].call(stdout_lines[0..-2], cmd_stderr.split("\n"), return_code)
               end
             end
           end
@@ -522,17 +520,17 @@ module HybridPlatformsConductor
         :test_on_check_node,
         @nodes.map { |node| { node: node } },
         tests_preparation: proc do |selected_tests|
-          nodes_to_test = selected_tests.map { |test| test.node }.uniq.sort
+          nodes_to_test = selected_tests.map(&:node).uniq.sort
           @outputs =
             if @skip_run
-              Hash[nodes_to_test.map do |node|
+              nodes_to_test.map do |node|
                 run_log_file_name = "#{@config.hybrid_platforms_dir}/run_logs/#{node}.stdout"
                 [
                   node,
                   # TODO: Find a way to also save stderr and the status code
-                  [0, File.exists?(run_log_file_name) ? File.read(run_log_file_name) : nil, '']
+                  [0, File.exist?(run_log_file_name) ? File.read(run_log_file_name) : nil, '']
                 ]
-              end]
+              end.to_h
             else
               # Why-run deploy on all nodes
               @deployer.concurrent_execution = !log_debug?
@@ -543,7 +541,7 @@ module HybridPlatformsConductor
               rescue
                 # If an exception occurred, make sure all concerned nodes are reporting the error
                 nodes_to_test.each do |node|
-                  error "Error while checking check-node output: #{$!}#{log_debug? ? "\n#{$!.backtrace.join("\n")}" : ''}", node: node
+                  error "Error while checking check-node output: #{$ERROR_INFO}#{log_debug? ? "\n#{$ERROR_INFO.backtrace.join("\n")}" : ''}", node: node
                 end
                 {}
               end
@@ -556,11 +554,11 @@ module HybridPlatformsConductor
           elsif stdout.is_a?(Symbol)
             test.error "Check-node run failed: #{stdout}."
           else
-            test.error "Check-node returned error code #{exit_status}" unless exit_status == 0
+            test.error "Check-node returned error code #{exit_status}" unless exit_status.zero?
             begin
               test.test_on_check_node(stdout, stderr, exit_status)
             rescue
-              test.error "Uncaught exception during test: #{$!}", $!.backtrace.join("\n")
+              test.error "Uncaught exception during test: #{$ERROR_INFO}", $ERROR_INFO.backtrace.join("\n")
             end
           end
         end