hybrid_platforms_conductor 33.0.0 → 33.0.1

data/spec/hybrid_platforms_conductor_test/executables/run_spec.rb

@@ -3,25 +3,23 @@ describe 'run executable' do
   # Setup a platform for run tests
   #
   # Parameters::
-  # * Proc: Code called when the platform is setup
+  # * *block* (Proc): Code called when the platform is setup
   #   * Parameters::
   #     * *repository* (String): Platform's repository
-  def with_test_platform_for_run
-    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
-      yield repository
-    end
+  def with_test_platform_for_run(&block)
+    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }, &block)
   end
 
   it 'executes a single command on a node' do
     with_test_platform_for_run do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+      expect_actions_executor_runs([proc do |actions|
         expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello'] }])
         test_actions_executor.stdout_device << "Hello\n"
         { 'node1' => [0, "Hello\n", ''] }
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello/
+      expect(stdout).to match(/Hello/)
       expect(stderr).to eq ''
     end
   end
@@ -30,15 +28,15 @@ describe 'run executable' do
     with_test_platform_for_run do |repository|
       commands_file = "#{repository}/commands.txt"
       File.write(commands_file, "echo Hello1\necho Hello2\n")
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+      expect_actions_executor_runs([proc do |actions|
         expect(actions).to eq(['node1'] => [{ remote_bash: [{ file: commands_file }] }])
         test_actions_executor.stdout_device << "Hello1\nHello2\n"
         { 'node1' => [0, "Hello1\nHello2\n", ''] }
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command-file', commands_file
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello1/
-      expect(stdout).to match /Hello2/
+      expect(stdout).to match(/Hello1/)
+      expect(stdout).to match(/Hello2/)
       expect(stderr).to eq ''
     end
   end
@@ -53,14 +51,14 @@ describe 'run executable' do
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello', '--timeout', '5'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello/
+      expect(stdout).to match(/Hello/)
       expect(stderr).to eq ''
     end
   end
 
   it 'executes a single command on a node and captures stderr correctly' do
     with_test_platform_for_run do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+      expect_actions_executor_runs([proc do |actions|
         expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello 2>&1'] }])
         test_actions_executor.stderr_device << "Hello\n"
         { 'node1' => [0, '', "Hello\n"] }
@@ -68,7 +66,7 @@ describe 'run executable' do
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello 2>&1'
       expect(exit_code).to eq 0
       expect(stdout).to eq ''
-      expect(stderr).to match /Hello/
+      expect(stderr).to match(/Hello/)
     end
   end
 
@@ -82,22 +80,22 @@ describe 'run executable' do
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--node', 'node2', '--command', 'echo Hello'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello/
+      expect(stdout).to match(/Hello/)
       expect(stderr).to eq ''
     end
   end
 
   it 'executes several commands' do
     with_test_platform_for_run do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+      expect_actions_executor_runs([proc do |actions|
         expect(actions).to eq(['node1'] => [{ remote_bash: ['echo Hello1', 'echo Hello2'] }])
         test_actions_executor.stdout_device << "Hello1\nHello2\n"
         { 'node1' => [0, "Hello1\nHello2\n", ''] }
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--command', 'echo Hello1', '--command', 'echo Hello2'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello1/
-      expect(stdout).to match /Hello2/
+      expect(stdout).to match(/Hello1/)
+      expect(stdout).to match(/Hello2/)
       expect(stderr).to eq ''
     end
   end
@@ -108,24 +106,26 @@ describe 'run executable' do
       File.write(commands_file_1, "echo Hello1\necho Hello2\n")
       commands_file_2 = "#{repository}/commands2.txt"
       File.write(commands_file_1, "echo Hello4\necho Hello5\n")
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
-        expect(actions).to eq(['node1'] => [{ remote_bash: [
-          { file: commands_file_1 },
-          'echo Hello3',
-          { file: commands_file_2 },
-          'echo Hello6'
-        ] }])
+      expect_actions_executor_runs([proc do |actions|
+        expect(actions).to eq(
+          ['node1'] => [{ remote_bash: [
+            { file: commands_file_1 },
+            'echo Hello3',
+            { file: commands_file_2 },
+            'echo Hello6'
+          ] }]
+        )
         test_actions_executor.stdout_device << "Hello1\nHello2\nHello3\nHello4\nHello5\nHello6\n"
         { 'node1' => [0, "Hello1\nHello2\nHello3\nHello4\nHello5\nHello6\n", ''] }
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--commands-file', commands_file_1, '--command', 'echo Hello3', '--commands-file', commands_file_2, '--command', 'echo Hello6'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello1/
-      expect(stdout).to match /Hello2/
-      expect(stdout).to match /Hello3/
-      expect(stdout).to match /Hello4/
-      expect(stdout).to match /Hello5/
-      expect(stdout).to match /Hello6/
+      expect(stdout).to match(/Hello1/)
+      expect(stdout).to match(/Hello2/)
+      expect(stdout).to match(/Hello3/)
+      expect(stdout).to match(/Hello4/)
+      expect(stdout).to match(/Hello5/)
+      expect(stdout).to match(/Hello6/)
       expect(stderr).to eq ''
     end
   end
@@ -140,14 +140,14 @@ describe 'run executable' do
       end])
       exit_code, stdout, stderr = run 'run', '--node', 'node1', '--node', 'node2', '--command', 'echo Hello', '--parallel'
       expect(exit_code).to eq 0
-      expect(stdout).to match /Hello/
+      expect(stdout).to match(/Hello/)
       expect(stderr).to eq ''
     end
   end
 
   it 'executes an interactive session on a node' do
     with_test_platform_for_run do
-      expect_actions_executor_runs([proc do |actions, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+      expect_actions_executor_runs([proc do |actions|
         expect(actions).to eq(['node1'] => [{ interactive: true }])
         { 'node1' => [0, '', ''] }
       end])

data/spec/hybrid_platforms_conductor_test/executables/ssh_config_spec.rb

@@ -3,31 +3,29 @@ describe 'ssh_config executable' do
   # Setup a platform for ssh_config tests
   #
   # Parameters::
-  # * Proc: Code called when the platform is setup
+  # * *block* (Proc): Code called when the platform is setup
   #   * Parameters::
   #     * *repository* (String): Platform's repository
-  def with_test_platform_for_ssh_config
-    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }) do |repository|
-      yield repository
-    end
+  def with_test_platform_for_ssh_config(&block)
+    with_test_platform({ nodes: { 'node1' => {}, 'node2' => {} } }, &block)
   end
 
   it 'dumps the SSH config without arguments' do
     with_test_platform_for_ssh_config do
-      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'ssh') { '# SSH config' }
+      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'ssh').and_return('# SSH config')
       exit_code, stdout, stderr = run 'ssh_config'
       expect(exit_code).to eq 0
-      expect(stdout).to match /# SSH config/
+      expect(stdout).to match(/# SSH config/)
       expect(stderr).to eq ''
     end
   end
 
   it 'dumps the SSH config with an alternate SSH executable' do
     with_test_platform_for_ssh_config do
-      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'my_ssh') { '# SSH config' }
+      expect(test_actions_executor.connector(:ssh)).to receive(:ssh_config).with(ssh_exec: 'my_ssh').and_return('# SSH config')
       exit_code, stdout, stderr = run 'ssh_config', '--ssh-exec', 'my_ssh'
       expect(exit_code).to eq 0
-      expect(stdout).to match /# SSH config/
+      expect(stdout).to match(/# SSH config/)
       expect(stderr).to eq ''
     end
   end

data/spec/hybrid_platforms_conductor_test/executables/test_spec.rb

@@ -3,13 +3,11 @@ describe 'test executable' do
   # Setup a platform for test tests
   #
   # Parameters::
-  # * Proc: Code called when the platform is setup
+  # * *block* (Proc): Code called when the platform is setup
   #   * Parameters::
   #     * *repository* (String): Platform's repository
-  def with_test_platform_for_test
-    with_test_platform({ nodes: { 'node' => {} } }) do |repository|
-      yield repository
-    end
+  def with_test_platform_for_test(&block)
+    with_test_platform({ nodes: { 'node' => {} } }, &block)
   end
 
   it 'executes a given test on a given node' do

data/spec/hybrid_platforms_conductor_test/helpers/actions_executor_helpers.rb

@@ -58,7 +58,7 @@ module HybridPlatformsConductorTest
       def with_connections_mocked_on(expected_nodes)
         expect(test_actions_executor).to receive(:with_connections_prepared_to) do |nodes, no_exception: false, &client_code|
           expect(nodes.sort).to eq expected_nodes.sort
-          client_code.call Hash[nodes.map { |node| [node, test_actions_executor.connector(:test_connector)] }]
+          client_code.call nodes.map { |node| [node, test_actions_executor.connector(:test_connector)] }.to_h
         end
         yield
       end
@@ -87,7 +87,7 @@ module HybridPlatformsConductorTest
       # Result::
       # * ActionsExecutor: ActionsExecutor on which we can do testing
       def test_actions_executor
-        @actions_executor = HybridPlatformsConductor::ActionsExecutor.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler unless @actions_executor
+        @actions_executor ||= HybridPlatformsConductor::ActionsExecutor.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler
         @actions_executor
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/cmd_runner_helpers.rb

@@ -38,6 +38,7 @@ module HybridPlatformsConductorTest
           remaining_expected_commands_mutex.synchronize do
             remaining_expected_commands.delete_if do |(expected_command, command_code, _options)|
               break unless found_command.nil?
+
               if (expected_command.is_a?(String) && expected_command == cmd) || (expected_command.is_a?(Regexp) && cmd =~ expected_command)
                 found_command = expected_command
                 found_command_code = command_code
@@ -86,8 +87,8 @@ module HybridPlatformsConductorTest
         end
         yield
         expect(
-          remaining_expected_commands.select do |(_expected_command, _command_code, options)|
-            !options[:optional]
+          remaining_expected_commands.reject do |(_expected_command, _command_code, options)|
+            options[:optional]
           end
         ).to eq([]), "Expected CmdRunner commands were not run:\n#{
           remaining_expected_commands.map do |(expected_command, _command_code, options)|
@@ -103,7 +104,7 @@ module HybridPlatformsConductorTest
       # Result::
       # * CmdRunner: CmdRunner on which we can do testing
       def test_cmd_runner
-        @cmd_runner = HybridPlatformsConductor::CmdRunner.new logger: logger, logger_stderr: logger unless @cmd_runner
+        @cmd_runner ||= HybridPlatformsConductor::CmdRunner.new logger: logger, logger_stderr: logger
         @cmd_runner
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/cmdb_helpers.rb

@@ -21,12 +21,12 @@ module HybridPlatformsConductorTest
       def register_test_cmdb(cmdb_names = [:test_cmdb])
         register_plugins(
           :cmdb,
-          Hash[cmdb_names.map do |plugin_id|
+          cmdb_names.map do |plugin_id|
             [
               plugin_id,
               HybridPlatformsConductorTest::CmdbPlugins.const_get(plugin_id.to_s.split('_').collect(&:capitalize).join.to_sym)
             ]
-          end]
+          end.to_h
         )
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/config_helpers.rb

@@ -9,7 +9,7 @@ module HybridPlatformsConductorTest
       # Result::
       # * Config: Config on which we can do testing
       def test_config
-        @config = HybridPlatformsConductor::Config.new logger: logger, logger_stderr: logger unless @config
+        @config ||= HybridPlatformsConductor::Config.new logger: logger, logger_stderr: logger
         @config
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -41,30 +41,30 @@ module HybridPlatformsConductorTest
           ssh_commands_per_connection = []
           if with_strict_host_key_checking
             ip = node_connection_info[:ip] || node_connection_info[:connection]
-            ssh_commands_once.concat([
+            ssh_commands_once.concat(
               [
-                "ssh-keyscan #{ip}",
-                proc { [0, "#{ip} ssh-rsa fake_host_key_for_#{ip}", ''] }
+                [
+                  "ssh-keyscan #{ip}",
+                  proc { [0, "#{ip} ssh-rsa fake_host_key_for_#{ip}", ''] }
+                ]
               ]
-            ])
+            )
           end
           if with_control_master_create
             control_master_created = false
             ssh_commands_per_connection << [
               if with_session_exec
-                /^.+\/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$/
+                %r{^.+/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$}
               else
                 unless ENV['hpc_interactive'] == 'false'
                   # Mock the user hitting enter as the Control Master will be created in another thread and the main thread waits for user input.
                   expect($stdin).to receive(:gets) do
                     # We have to wait for the Control Master creation thread to actually create the Control Master before hitting Enter.
-                    while !control_master_created do
-                      sleep 0.1
-                    end
+                    sleep 0.1 until control_master_created
                     "\n"
                   end
                 end
-                /^xterm -e '.+\/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$/
+                %r{^xterm -e '.+/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$}
               end,
               proc do
                 control_file = test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user])
@@ -88,13 +88,13 @@ module HybridPlatformsConductorTest
           end
           if with_control_master_check
             ssh_commands_per_connection << [
-              /^.+\/ssh -O check hpc\.#{Regexp.escape(node)}$/,
+              %r{^.+/ssh -O check hpc\.#{Regexp.escape(node)}$},
               proc { [0, '', ''] }
             ]
           end
           if with_control_master_destroy
             ssh_commands_per_connection << [
-              /^.+\/ssh -O exit hpc\.#{Regexp.escape(node)} 2>&1 \| grep -v 'Exit request sent\.'$/,
+              %r{^.+/ssh -O exit hpc\.#{Regexp.escape(node)} 2>&1 \| grep -v 'Exit request sent\.'$},
               proc do
                 # Really mock the control file deletion
                 File.unlink(test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user]))
@@ -137,8 +137,7 @@ module HybridPlatformsConductorTest
       )
         with_test_platform(
           { nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: session_exec } } } },
-          false,
-          additional_config
+          additional_config: additional_config
         ) do
           with_cmd_runner_mocked(
             [

data/spec/hybrid_platforms_conductor_test/helpers/deployer_helpers.rb

@@ -12,7 +12,7 @@ module HybridPlatformsConductorTest
       # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
       def expect_action_to_lock_node(action, node, sudo: 'sudo -u root')
         expect(action[:scp].size).to eq 1
-        expect(action[:scp].first[0]).to match /^.+\/mutex_dir$/
+        expect(action[:scp].first[0]).to match(%r{^.+/mutex_dir$})
         expect(action[:scp].first[1]).to eq '.'
         expect(action[:remote_bash]).to eq "while ! #{sudo ? "#{sudo} " : ''}./mutex_dir lock /tmp/hybrid_platforms_conductor_deploy_lock \"$(ps -o ppid= -p $$)\"; do echo -e 'Another deployment is running on #{node}. Waiting for it to finish to continue...' ; sleep 5 ; done"
       end
@@ -23,7 +23,7 @@ module HybridPlatformsConductorTest
       # * *action* (Hash<Symbol,Object>): The action to check
       # * *node* (String): The concerned node
       # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
-      def expect_action_to_unlock_node(action, node, sudo: 'sudo -u root')
+      def expect_action_to_unlock_node(action, _node, sudo: 'sudo -u root')
         expect(action).to eq(remote_bash: "#{sudo ? "#{sudo} " : ''}./mutex_dir unlock /tmp/hybrid_platforms_conductor_deploy_lock")
       end
 
@@ -40,7 +40,7 @@ module HybridPlatformsConductorTest
       # * Hash<String, [Integer or Symbol, String, String] >: Expected result of those expected actions
       def expect_actions_to_deploy_on(actions, nodes, check: false, sudo: 'sudo -u root', expected_actions: [], mocked_result: nil)
         nodes = [nodes] if nodes.is_a?(String)
-        mocked_result = Hash[nodes.map { |node| [node, [0, "#{check ? 'Check' : 'Deploy'} successful", '']] }] if mocked_result.nil?
+        mocked_result = nodes.map { |node| [node, [0, "#{check ? 'Check' : 'Deploy'} successful", '']] }.to_h if mocked_result.nil?
         expect(actions.size).to eq nodes.size
         nodes.each do |node|
           expect(actions.key?(node)).to eq true
@@ -65,7 +65,7 @@ module HybridPlatformsConductorTest
           expect(actions.key?(node)).to eq true
           expect_action_to_unlock_node(actions[node], node, sudo: sudo)
         end
-        Hash[nodes.map { |node| [node, [0, 'Release mutex successful', '']] }]
+        nodes.map { |node| [node, [0, 'Release mutex successful', '']] }.to_h
       end
 
       # Expect a given set of actions to upload log files on a list of nodes (using the test_log log plugin)
@@ -80,7 +80,7 @@ module HybridPlatformsConductorTest
           expect(actions.key?(node)).to eq true
           expect(actions[node]).to eq [{ bash: "echo Save test logs to #{node}" }]
         end
-        Hash[nodes.map { |node| [node, [0, 'Logs uploaded', '']] }]
+        nodes.map { |node| [node, [0, 'Logs uploaded', '']] }.to_h
       end
 
       # Get a test Deployer
@@ -88,7 +88,7 @@ module HybridPlatformsConductorTest
       # Result::
       # * Deployer: Deployer on which we can do testing
       def test_deployer
-        @deployer = HybridPlatformsConductor::Deployer.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor, services_handler: test_services_handler unless @deployer
+        @deployer ||= HybridPlatformsConductor::Deployer.new logger: logger, logger_stderr: logger, config: test_config, cmd_runner: test_cmd_runner, nodes_handler: test_nodes_handler, actions_executor: test_actions_executor, services_handler: test_services_handler
         @deployer
       end
 
@@ -99,11 +99,8 @@ module HybridPlatformsConductorTest
       def expect_services_handler_to_deploy(services)
         expect(test_services_handler).to receive(:deploy_allowed?).with(
           services: services,
-          secrets: {},
           local_environment: false
-        ) do
-          nil
-        end
+        ).and_return(nil)
         expect(test_services_handler).to receive(:package).with(
           services: services,
           secrets: {},
@@ -115,20 +112,225 @@ module HybridPlatformsConductorTest
           local_environment: false,
           why_run: false
         )
-        services.each do |node, services|
-          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, services, false) do
+        services.each do |node, node_services|
+          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, node_services, false) do
             [{ bash: "echo \"Deploying on #{node}\"" }]
           end
-          expect(test_services_handler).to receive(:log_info_for).with(node, services) do
+          expect(test_services_handler).to receive(:log_info_for).with(node, node_services) do
             {
               repo_name_0: 'platform',
               commit_id_0: '123456',
-              commit_message_0: "Test commit for #{node}: #{services.join(', ')}"
+              commit_message_0: "Test commit for #{node}: #{node_services.join(', ')}"
             }
           end
         end
       end
 
+      # Get expected actions for a deployment
+      #
+      # Parameters::
+      # * *services* (Hash<String, Array<String> >): Expected nodes that should be deployed, with their corresponding services [default: { 'node' => %w[service] }]
+      # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
+      # * *check_mode* (Boolean): Are we testing in check mode? [default: @check_mode]
+      # * *mocked_deploy_result* (Hash or nil): Mocked result of the deployment actions, or nil to use the helper's default [default: nil]
+      # * *additional_expected_actions* (Array): Additional expected actions [default: []]
+      # * *expect_concurrent_actions* (Boolean): Are actions expected to be run in parallel? [default: false]
+      # * *expect_actions_timeout* (Integer or nil): Expected timeout in actions, or nil for none [default: nil]
+      def expected_actions_for_deploy_on(
+        services: { 'node' => %w[service] },
+        sudo: 'sudo -u root',
+        check_mode: @check_mode,
+        mocked_deploy_result: nil,
+        additional_expected_actions: [],
+        expect_concurrent_actions: false,
+        expect_actions_timeout: nil
+      )
+        actions = [
+          # First run, we expect the mutex to be setup, and the deployment actions to be run
+          proc do |actions_per_nodes, timeout: nil, concurrent: false, log_to_dir: 'run_logs', log_to_stdout: true|
+            expect(timeout).to eq expect_actions_timeout
+            expect(concurrent).to eq expect_concurrent_actions
+            expect(log_to_dir).to eq 'run_logs'
+            expect_actions_to_deploy_on(
+              actions_per_nodes,
+              services.keys,
+              check: check_mode,
+              sudo: sudo,
+              mocked_result: mocked_deploy_result,
+              expected_actions: additional_expected_actions
+            )
+          end,
+          # Second run, we expect the mutex to be released
+          proc { |actions_per_nodes| expect_actions_to_unlock(actions_per_nodes, services.keys, sudo: sudo) }
+        ]
+        services.each do |node, node_services|
+          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, node_services, check_mode) do
+            [{ bash: "echo \"#{check_mode ? 'Checking' : 'Deploying'} on #{node}\"" }]
+          end
+        end
+        # Third run, we expect logs to be uploaded on the node (only if not check mode)
+        unless check_mode
+          services.each do |node, node_services|
+            expect(test_services_handler).to receive(:log_info_for).with(node, node_services).and_return(
+              repo_name_0: 'platform',
+              commit_id_0: '123456',
+              commit_message_0: 'Test commit'
+            )
+          end
+          actions << proc { |actions_per_nodes| expect_actions_to_upload_logs(actions_per_nodes, services.keys) }
+        end
+        actions
+      end
+
+      # Prepare a platform ready to test deployments on.
+      #
+      # Parameters::
+      # * *nodes_info* (Hash): Node info to give the platform [default: 1 node having 1 service]
+      # * *expect_services_to_deploy* (Hash<String,Array<String>>): Expected services to be deployed [default: all services from nodes_info]
+      # * *expect_deploy_allowed* (Boolean): Should we expect the call to deploy_allowed? [default: true]
+      # * *expect_package* (Boolean): Should we expect packaging? [default: true]
+      # * *expect_prepare_for_deploy* (Boolean): Should we expect calls to prepare for deploy? [default: true]
+      # * *expect_connections_to_nodes* (Boolean): Should we expect connections to nodes? [default: true]
+      # * *expect_default_actions* (Boolean): Should we expect default actions? [default: true]
+      # * *expect_sudo* (String or nil): Expected sudo command, or nil if none [default: 'sudo -u root']
+      # * *expect_secrets* (Hash): Secrets to be expected during deployment [default: {}]
+      # * *expect_local_environment* (Boolean): Expected local environment flag [default: false]
+      # * *expect_additional_actions* (Array): Additional expected actions [default: []]
+      # * *expect_concurrent_actions* (Boolean): Are actions expected to be run in parallel? [default: false]
+      # * *expect_actions_timeout* (Integer or nil): Expected timeout in actions, or nil for none [default: nil]
+      # * *check_mode* (Boolean): Are we testing in check mode? [default: @check_mode]
+      # * *additional_config* (String): Additional configuration to set [default: '']
+      # * Proc: Code called once the platform is ready for testing the deployer
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_platform_to_deploy(
+        nodes_info: { nodes: { 'node' => { services: %w[service] } } },
+        expect_services_to_deploy: nodes_info[:nodes].transform_values { |node_info| node_info[:services] },
+        expect_deploy_allowed: true,
+        expect_package: true,
+        expect_prepare_for_deploy: true,
+        expect_connections_to_nodes: true,
+        expect_default_actions: true,
+        expect_sudo: 'sudo -u root',
+        expect_secrets: {},
+        expect_local_environment: false,
+        expect_additional_actions: [],
+        expect_concurrent_actions: false,
+        expect_actions_timeout: nil,
+        check_mode: @check_mode,
+        additional_config: ''
+      )
+        with_test_platform(nodes_info, as_git: !check_mode, additional_config: "#{additional_config}\nsend_logs_to :test_log") do |repository|
+          # Mock the ServicesHandler accesses
+          if !check_mode && expect_deploy_allowed
+            expect(test_services_handler).to receive(:deploy_allowed?).with(
+              services: expect_services_to_deploy,
+              local_environment: expect_local_environment
+            ).and_return(nil)
+          end
+          if expect_package
+            expect(test_services_handler).to receive(:package).with(
+              services: expect_services_to_deploy,
+              secrets: expect_secrets,
+              local_environment: expect_local_environment
+            )
+          else
+            expect(test_services_handler).not_to receive(:package)
+          end
+          if expect_prepare_for_deploy
+            expect(test_services_handler).to receive(:prepare_for_deploy).with(
+              services: expect_services_to_deploy,
+              secrets: expect_secrets,
+              local_environment: expect_local_environment,
+              why_run: check_mode
+            )
+          else
+            expect(test_services_handler).not_to receive(:prepare_for_deploy)
+          end
+          test_deployer.use_why_run = true if check_mode
+          if expect_connections_to_nodes
+            with_connections_mocked_on(expect_services_to_deploy.keys) do
+              if expect_default_actions
+                expect_actions_executor_runs(
+                  expected_actions_for_deploy_on(
+                    services: expect_services_to_deploy,
+                    check_mode: check_mode,
+                    sudo: expect_sudo,
+                    additional_expected_actions: expect_additional_actions,
+                    expect_concurrent_actions: expect_concurrent_actions,
+                    expect_actions_timeout: expect_actions_timeout
+                  )
+                )
+              end
+              yield repository
+            end
+          else
+            yield repository
+          end
+        end
+      end
+
+      # Prepare a directory with certificates
+      #
+      # Parameters::
+      # * Proc: Code called with the directory created with a mocked certificate
+      #   * Parameters::
+      #     * *certs_dir* (String): Directory containing certificates
+      def with_certs_dir
+        with_repository do |repository|
+          certs_dir = "#{repository}/certificates"
+          FileUtils.mkdir_p certs_dir
+          File.write("#{certs_dir}/test_cert.crt", 'Hello')
+          yield certs_dir
+        end
+      end
+
+      # Prepare a platform ready to test deployments' retries on.
+      #
+      # Parameters::
+      # * *nodes_info* (Hash): Node info to give the platform [default: { nodes: { 'node' => {} } }]
+      # * *block* (Proc): Code called once the platform is ready for testing the deployer
+      #   * Parameters::
+      #     * *repository* (String): Path to the repository
+      def with_platform_to_retry_deploy(nodes_info: { nodes: { 'node' => { services: %w[service] } } }, &block)
+        with_platform_to_deploy(
+          nodes_info: nodes_info,
+          expect_default_actions: false,
+          additional_config: "
+          for_nodes([#{nodes_info[:nodes].keys.map { |node| "'#{node}'" }.join(', ')}]) do
+            retry_deploy_for_errors_on_stdout [
+              'stdout non-deterministic error'
+            ]
+            retry_deploy_for_errors_on_stderr [
+              'stderr non-deterministic error',
+              /stderr regexp error \\d+/
+            ]
+          end
+          for_nodes([#{nodes_info[:nodes].keys.map { |node| "'#{node}'" }.join(', ')}]) do
+            retry_deploy_for_errors_on_stdout [
+              /stdout regexp error \\d+/
+            ]
+          end
+          ",
+          &block
+        )
+      end
+
+      # Mock a sequential list of deployments
+      #
+      # Parameters::
+      # * *statuses* (Array<Hash<String,Status> or Status>)>): List of mocked deployment statuses per node name, or just the status for the default node.
+      #   A status is a triplet [Integer or Symbol, String, String]: exit status, stdout and stderr.
+      def mock_deploys_with(statuses)
+        expect_actions_executor_runs(statuses.map do |status|
+          status = { 'node' => status } if status.is_a?(Array)
+          expected_actions_for_deploy_on(
+            services: status.keys.map { |node| [node, %w[service]] }.to_h,
+            mocked_deploy_result: status
+          )
+        end.flatten)
+      end
+
     end
 
   end